LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::LowerBound(std::shared_ptr<fishdb::MemPage>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KVIter BTree::LowerBound(std::shared_ptr<MemPage> mp, const std::string &key)
{
    for (auto iter = mp->kvs.begin(); iter != mp->kvs.end(); ++iter)
    {
        if (!m_cmp_func(iter->key, key))
            return iter;
    }
    return mp->kvs.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq 0x60(%rax), %r12
movq 0x68(%rax), %rax
cmpq %rax, %r12
je 0x3624
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %r13
cmpq $0x0, 0x60(%r15)
je 0x3633
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *0x68(%r15)
testb %al, %al
je 0x3621
addq $0x40, %r12
movq (%r14), %rax
movq 0x68(%rax), %rax
cmpq %rax, %r12
jne 0x35f7
jmp 0x3624
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::UpperBound(std::shared_ptr<fishdb::MemPage>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KVIter BTree::UpperBound(std::shared_ptr<MemPage> mp, const std::string &key)
{
    for (auto iter = mp->kvs.begin(); iter != mp->kvs.end(); ++iter)
    {
        if (m_cmp_func(key, iter->key))
            return iter;
    }
    return mp->kvs.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq 0x60(%rax), %r12
movq 0x68(%rax), %rax
cmpq %rax, %r12
je 0x3690
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %r13
cmpq $0x0, 0x60(%r15)
je 0x369f
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x68(%r15)
testb %al, %al
jne 0x368d
addq $0x40, %r12
movq (%r14), %rax
movq 0x68(%rax), %rax
cmpq %rax, %r12
jne 0x3663
jmp 0x3690
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int BTree::Get(const std::string &key, std::string &data)
{
    auto now = m_root;
    while (now != NULL)
    {
        auto iter = LowerBound(now, key);
        size_t p = iter - now->kvs.begin();
        if (iter != now->kvs.end() && Equal(iter->key, key))
        {
            data = iter->value;
            return BT_OK;
        }
        else if (!now->is_leaf)
            now = ReadPage(now->children[p]);
        else
            return BT_NOT_FOUND;
    }
    return BT_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r12
movq 0x70(%rdi), %r13
movq 0x78(%rdi), %rbx
testq %rbx, %rbx
je 0x3752
movq 0x888c(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x374e
incl 0x8(%rbx)
jmp 0x3752
lock
incl 0x8(%rbx)
testq %r13, %r13
je 0x3842
movq %r13, -0x60(%rbp)
movq %rbx, -0x58(%rbp)
testq %rbx, %rbx
je 0x377d
movq 0x8861(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x3779
incl 0x8(%rbx)
jmp 0x377d
lock
incl 0x8(%rbx)
movq %r12, %rdi
leaq -0x60(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x35cc
movq %rax, %r14
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x379e
callq 0x277e
movq %r14, %r15
subq 0x60(%r13), %r15
cmpq 0x68(%r13), %r14
je 0x37dc
movq %r12, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %rdx
callq 0x357c
testb %al, %al
je 0x37dc
addq $0x20, %r14
movl $0x0, -0x2c(%rbp)
movq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x2110
movq %rbx, %r14
xorl %eax, %eax
jmp 0x3835
cmpb $0x0, 0x79(%r13)
je 0x37f1
movl $0xfffffffe, -0x2c(%rbp) # imm = 0xFFFFFFFE
xorl %eax, %eax
movq %rbx, %r14
jmp 0x3835
movq 0x48(%r13), %rax
sarq $0x3, %r15
movq (%rax,%r15), %rdx
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x351a
movq -0x50(%rbp), %r13
movq -0x48(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
testq %rbx, %rbx
je 0x3825
movq %rbx, %rdi
callq 0x277e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3833
callq 0x277e
movb $0x1, %al
movq %r14, %rbx
testb %al, %al
jne 0x3752
jmp 0x384c
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq %rbx, %r14
testq %r14, %r14
je 0x3859
movq %r14, %rdi
callq 0x277e
movl -0x2c(%rbp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x386f
jmp 0x386f
movq %rax, %r14
jmp 0x3885
movq %rax, %r14
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x3885
callq 0x277e
testq %rbx, %rbx
je 0x3892
movq %rbx, %rdi
callq 0x277e
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::Keys[abi:cxx11](fishdb::MemPage*)
std::string BTree::Keys(MemPage *mp)
{
    std::ostringstream out;
    out << "[";
    for (size_t i = 0; i < mp->kvs.size(); ++i)
    {
        out << mp->kvs[i].key << ((i == mp->kvs.size() - 1) ? "" : " ");
    }
    out << "]";

    return out.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %r15
movq %r15, %rdi
callq 0x2270
leaq 0x3a0f(%rip), %rsi      # 0x8329
movl $0x1, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, -0x30(%rbp)
movq 0x60(%r14), %rax
cmpq %rax, 0x68(%r14)
je 0x49a2
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x39e6(%rip), %rbx      # 0x832b
leaq 0x37db(%rip), %r15      # 0x8127
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x2230
movq 0x68(%r14), %rcx
subq 0x60(%r14), %rcx
sarq $0x6, %rcx
decq %rcx
xorl %edx, %edx
cmpq %rcx, %r13
setne %dl
movq %r15, %rsi
cmovneq %rbx, %rsi
movq %rax, %rdi
callq 0x2230
incq %r13
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
addq $0x40, %r12
cmpq %rcx, %r13
jb 0x494c
leaq 0x3984(%rip), %rsi      # 0x832d
leaq -0x1a8(%rbp), %rdi
movl $0x1, %edx
callq 0x2230
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22d0
movq 0x75f4(%rip), %rsi      # 0xbfc8
leaq -0x1a8(%rbp), %rdi
callq 0x2100
leaq -0x138(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a03
movq %rax, %rbx
movq 0x75bb(%rip), %rsi      # 0xbfc8
leaq -0x1a8(%rbp), %rdi
callq 0x2100
leaq -0x138(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::Childen[abi:cxx11](fishdb::MemPage*)
std::string BTree::Childen(MemPage *mp)
{
    std::ostringstream out;
    out << "[";
    for (size_t i = 0; i < mp->children.size(); ++i)
    {
        out << mp->children[i] << ((i == mp->children.size() - 1) ? "" : " ");
    }
    out << "]";

    return out.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %r15
movq %r15, %rdi
callq 0x2270
leaq 0x38cb(%rip), %rsi      # 0x8329
movl $0x1, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, -0x30(%rbp)
movq 0x48(%r14), %rax
cmpq %rax, 0x50(%r14)
je 0x4ad3
xorl %r12d, %r12d
leaq 0x38a8(%rip), %r13      # 0x832b
leaq 0x369d(%rip), %rbx      # 0x8127
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x21c0
movq 0x50(%r14), %rcx
subq 0x48(%r14), %rcx
sarq $0x3, %rcx
decq %rcx
xorl %edx, %edx
cmpq %rcx, %r12
setne %dl
movq %rbx, %rsi
cmovneq %r13, %rsi
movq %rax, %rdi
callq 0x2230
incq %r12
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x4a8a
leaq 0x3853(%rip), %rsi      # 0x832d
leaq -0x1a8(%rbp), %rdi
movl $0x1, %edx
callq 0x2230
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22d0
movq 0x74c3(%rip), %rsi      # 0xbfc8
leaq -0x1a8(%rbp), %rdi
callq 0x2100
leaq -0x138(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b34
movq %rax, %rbx
movq 0x748a(%rip), %rsi      # 0xbfc8
leaq -0x1a8(%rbp), %rdi
callq 0x2100
leaq -0x138(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::Print(std::shared_ptr<fishdb::MemPage>)
void BTree::Print(std::shared_ptr<MemPage> mp)
{
    printf("%" PRId64 ", %s -> %s\n", mp->header.page_no, Keys(mp.get()).c_str(), Childen(mp.get()).c_str());
    for (size_t i = 0; i < mp->children.size(); ++i)
    {
        auto child = ReadPage(mp->children[i]);
        Print(ReadPage(mp->children[i]));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdx
movq (%rdx), %r15
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x48ea
movq (%r12), %r12
movq (%rbx), %rdx
leaq -0x78(%rbp), %rdi
callq 0x4a2e
leaq -0x68(%rbp), %r13
movq -0x10(%r13), %rcx
leaq 0x3789(%rip), %rdi      # 0x832f
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x4bc1
callq 0x21b0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bd3
callq 0x21b0
movq (%rbx), %rcx
movq 0x48(%rcx), %rax
cmpq %rax, 0x50(%rcx)
je 0x4c51
xorl %r13d, %r13d
leaq -0x58(%rbp), %r15
leaq -0x38(%rbp), %r12
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x351a
movq (%rbx), %rax
movq 0x48(%rax), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x351a
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b5e
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4c29
callq 0x277e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4c37
callq 0x277e
incq %r13
movq (%rbx), %rcx
movq 0x48(%rcx), %rax
movq 0x50(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x4beb
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c9b
callq 0x21b0
jmp 0x4c9b
movq %rax, %rbx
jmp 0x4c8d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4c8d
callq 0x277e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4c9b
callq 0x277e
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::Init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Pager::Init(std::string file)
{
    m_db_header = new DBHeader();

    m_file = fopen(file.c_str(), "rb+");
    if (m_file == NULL)
        m_file = fopen(file.c_str(), "wb+");
    assert(m_file);
    fseek(m_file, 0L, SEEK_END);
    m_file_size = ftell(m_file);
    fseek(m_file, 0, SEEK_SET);

    if (m_file_size < PG_SIZE)
    {
        memset(m_db_header, 0, sizeof(DBHeader));
        m_db_header->free_list = -1;
        m_db_header->root_page = -1;
        m_db_header->total_pages = 1;
        ftruncate(fileno(m_file), PG_SIZE);
        m_file_size = PG_SIZE;
        fseek(m_file, 0, SEEK_SET);
        fwrite((char *)m_db_header, sizeof(DBHeader), 1, m_file);
    }
    else
    {
        // TODO do some check
        fread((void *)m_db_header, sizeof(DBHeader), 1, m_file);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21f0
pxor %xmm0, %xmm0
movdqa %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x30(%rbx)
movq (%r14), %rdi
leaq 0x2360(%rip), %rsi      # 0x83a1
callq 0x2250
movq %rax, 0x38(%rbx)
testq %rax, %rax
jne 0x6062
movq (%r14), %rdi
leaq 0x234c(%rip), %rsi      # 0x83a5
callq 0x2250
movq %rax, 0x38(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6124
xorl %esi, %esi
movl $0x2, %edx
callq 0x2220
movq 0x38(%rbx), %rdi
callq 0x2030
movq %rax, 0x40(%rbx)
movq 0x38(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
movq 0x30(%rbx), %rdi
cmpq $0x1ff, 0x40(%rbx)      # imm = 0x1FF
jg 0x610a
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rbx), %rax
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rax)
movq $0x1, 0x10(%rax)
movq 0x38(%rbx), %rdi
callq 0x2210
movl $0x200, %esi            # imm = 0x200
movl %eax, %edi
callq 0x2280
movq $0x200, 0x40(%rbx)      # imm = 0x200
movq 0x38(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rcx
movl $0x18, %esi
movl $0x1, %edx
callq 0x2320
jmp 0x611d
movq 0x38(%rbx), %rcx
movl $0x18, %esi
movl $0x1, %edx
callq 0x22b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x227e(%rip), %rdi      # 0x83a9
leaq 0x227e(%rip), %rsi      # 0x83b0
leaq 0x2283(%rip), %rcx      # 0x83bc
movl $0x10, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::Close()
void Pager::Close()
{
    fseek(m_file, 0, SEEK_SET);
    fwrite((char *)m_db_header, sizeof(DBHeader), 1, m_file);
    Prune(0, true);
    fclose(m_file);
    delete m_db_header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rcx
movl $0x18, %esi
movl $0x1, %edx
callq 0x2320
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x61a0
movq 0x38(%rbx), %rdi
callq 0x21e0
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x619d
popq %rbx
popq %rbp
jmp 0x21b0
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::Prune(int, bool)
void Pager::Prune(int size_limit, bool force)
{
    std::vector<int64_t> ps;
    for (auto iter = m_pages.begin(); iter != m_pages.end(); ++iter)
    {
        if ((int)m_pages.size() <= size_limit) break;
        auto mp = iter->second;
        if (mp->stick && !force) continue;
        FlushPage(mp);
        ps.push_back(iter->first);
    }
    for (size_t i = 0; i < ps.size(); ++i)
        m_pages.erase(ps[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x18(%rdi), %r12
leaq 0x8(%rdi), %r14
cmpq %r14, %r12
je 0x62a0
movl %esi, %r15d
cmpl %r15d, 0x28(%rbx)
jle 0x62a0
movq 0x28(%r12), %rax
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x620a
movq 0x5dd6(%rip), %rcx      # 0xbfd0
cmpb $0x0, (%rcx)
je 0x6205
incl 0x8(%r13)
jmp 0x620a
lock
incl 0x8(%r13)
movb 0x78(%rax), %cl
xorb $0x1, %cl
orb -0x2c(%rbp), %cl
cmpb $0x1, %cl
jne 0x627e
movq %rax, -0x60(%rbp)
movq %r13, -0x58(%rbp)
testq %r13, %r13
je 0x623c
movq 0x5da4(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x6237
incl 0x8(%r13)
jmp 0x623c
lock
incl 0x8(%r13)
movq %rbx, %rdi
leaq -0x60(%rbp), %rsi
callq 0x6a2c
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x6256
callq 0x277e
leaq 0x20(%r12), %rdx
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x6275
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x627e
leaq -0x50(%rbp), %rdi
callq 0x5a12
testq %r13, %r13
je 0x628b
movq %r13, %rdi
callq 0x277e
movq %r12, %rdi
callq 0x2160
cmpq %r14, %rax
je 0x62a0
movq %rax, %r12
jmp 0x61da
movq -0x50(%rbp), %rsi
cmpq %rsi, -0x48(%rbp)
je 0x62e1
xorl %r14d, %r14d
xorl %r15d, %r15d
addq %r14, %rsi
movq %rbx, %rdi
callq 0x7106
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7188
incq %r15
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r14
cmpq %rax, %r15
jb 0x62b0
testq %rsi, %rsi
je 0x62ee
movq %rsi, %rdi
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6313
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x6313
callq 0x277e
testq %r13, %r13
je 0x6325
movq %r13, %rdi
callq 0x277e
jmp 0x6325
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6333
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::GetRoot()
std::shared_ptr<MemPage> Pager::GetRoot()
{
    if (m_db_header->root_page == -1)
    {
        auto mp = NewPage(TREE_PAGE);
        SetRoot(mp->header.page_no);
        mp->is_leaf = true;
        return mp;
    }
    else
    {
        auto mp = GetPage(m_db_header->root_page);
        assert(mp->header.page_no == m_db_header->root_page);
        return mp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rdx
cmpq $-0x1, %rdx
je 0x638d
xorl %ecx, %ecx
callq 0x65c6
movq (%rbx), %rax
movq (%rax), %rax
movq 0x30(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x63a9
leaq 0x206c(%rip), %rdi      # 0x83e1
leaq 0x2034(%rip), %rsi      # 0x83b0
leaq 0x208b(%rip), %rcx      # 0x840e
movl $0x3d, %edx
callq 0x2140
movl $0x2, %edx
callq 0x63b2
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x30(%r14), %rdx
movq %rcx, 0x8(%rdx)
movb $0x1, 0x79(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::WritePage(std::shared_ptr<fishdb::MemPage>)
void Pager::WritePage(std::shared_ptr<MemPage> mp)
{
    int64_t page_no = mp->header.page_no;
    auto header = &mp->header;
    int64_t offset = page_no * PG_SIZE;
    if (offset + PG_SIZE > m_file_size)
    {
        ftruncate(fileno(m_file), offset + PG_SIZE);
        m_file_size = offset + PG_SIZE;
    }

    assert(mp->data.size() <= PAGE_CAPA);
    fseek(m_file, offset, SEEK_SET);
    fwrite((void *)header, sizeof(PageHeader), 1, m_file);
    int len = std::min((int)PAGE_CAPA, (int)mp->data.size());
    fwrite((void *)mp->data.c_str(), len, 1, m_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq (%r15), %r12
shlq $0x9, %r12
leaq 0x200(%r12), %r13
cmpq 0x40(%rdi), %r13
jle 0x6d4f
movq 0x38(%rbx), %rdi
callq 0x2210
movl %eax, %edi
movq %r13, %rsi
callq 0x2280
movq %r13, 0x40(%rbx)
movq (%r14), %rax
cmpq $0x1d9, 0x30(%rax)      # imm = 0x1D9
jae 0x6db3
movq 0x38(%rbx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2220
movq 0x38(%rbx), %rcx
movl $0x28, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x2320
movq (%r14), %rax
movl 0x30(%rax), %ecx
movl $0x1d8, %edx            # imm = 0x1D8
cmpl %edx, %ecx
cmovll %ecx, %edx
movq 0x28(%rax), %rdi
movslq %edx, %rsi
movq 0x38(%rbx), %rcx
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2320
leaq 0x1744(%rip), %rdi      # 0x84fe
leaq 0x15ef(%rip), %rsi      # 0x83b0
leaq 0x1753(%rip), %rcx      # 0x851b
movl $0xdc, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %r15
movb 0x79(%rdi), %al
movb %al, 0x26(%rdi)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsi)
leaq 0x28(%rsi), %rdi
movq 0x50(%r15), %rsi
subq 0x48(%r15), %rsi
shrq $0x3, %rsi
callq 0x77a6
cltq
movq %rbx, -0x30(%rbp)
leaq (%rbx,%rax), %r12
addq $0x28, %r12
movq 0x48(%r15), %rax
cmpq %rax, 0x50(%r15)
je 0x74c0
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
callq 0x77b3
movslq %eax, %r13
addq %r12, %r13
incq %rbx
movq 0x48(%r15), %rax
movq 0x50(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %r13, %r12
cmpq %rcx, %rbx
jb 0x7492
jmp 0x74c3
movq %r12, %r13
movq 0x68(%r15), %rsi
subq 0x60(%r15), %rsi
shrq $0x6, %rsi
movq %r13, %rdi
callq 0x77a6
movslq %eax, %r12
addq %r13, %r12
movq 0x60(%r15), %rsi
cmpq %rsi, 0x68(%r15)
je 0x7532
xorl %ebx, %ebx
xorl %r14d, %r14d
addq %rbx, %rsi
movq %r12, %rdi
callq 0x77c1
movslq %eax, %r13
addq %r12, %r13
movq 0x60(%r15), %rax
leaq (%rax,%rbx), %rsi
addq $0x20, %rsi
movq %r13, %rdi
callq 0x77c1
movslq %eax, %r12
addq %r13, %r12
incq %r14
movq 0x60(%r15), %rsi
movq 0x68(%r15), %rax
subq %rsi, %rax
sarq $0x6, %rax
addq $0x40, %rbx
cmpq %rax, %r14
jb 0x74ec
subl -0x30(%rbp), %r12d
movq -0x38(%rbp), %rax
movl %r12d, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
leaq 0x4c8e(%rip), %r15      # 0xc200
movq %r15, %rdi
callq 0x2190
cmpb $0x0, 0x26(%rbx)
setne 0x79(%rbx)
leaq -0x2c(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7818
movslq %eax, %r14
addq %r15, %r14
cmpl $0x0, (%r12)
jle 0x75f7
leaq 0x48(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r15d, %r15d
leaq -0xb8(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x7827
movl %eax, %r13d
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x75dc
movq -0xb8(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x75e8
movq -0x38(%rbp), %rdi
movq %r12, %rdx
callq 0x5a12
movslq %r13d, %rax
addq %rax, %r14
incl %r15d
cmpl -0x2c(%rbp), %r15d
jl 0x75b0
movq %rbx, -0x38(%rbp)
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7818
cmpl $0x0, (%r15)
jle 0x76ed
cltq
addq %rax, %r14
addq $0x60, -0x38(%rbp)
leaq -0xb8(%rbp), %rbx
xorl %r13d, %r13d
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %ecx, %ecx
movq %rcx, -0x50(%rbp)
movb %cl, -0x48(%rbp)
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rcx, -0x70(%rbp)
movb %cl, -0x68(%rbp)
movq %r14, %rdi
leaq -0x58(%rbp), %rsi
callq 0x7838
leaq -0x78(%rbp), %r12
cltq
addq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x7838
movl %eax, %r15d
movq %rbx, %rdi
leaq -0x58(%rbp), %rsi
movq %r12, %rdx
callq 0x4d18
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x7742
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x769e
callq 0x21b0
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x76b6
callq 0x21b0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x76c8
callq 0x21b0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x76da
callq 0x21b0
movslq %r15d, %rax
addq %rax, %r14
incl %r13d
cmpl -0x2c(%rbp), %r13d
jl 0x7628
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7712
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x4d80
jmp 0x7715
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x7727
callq 0x21b0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7739
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movslq (%rdi), %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4(%rdi,%r15), %rdx
leaq 0x4(%rdi), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x7894
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x7883
callq 0x21b0
leal 0x4(%r15), %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rdx, -0x18(%r14)
callq 0x20f0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x4742
movq -0x28(%rbp), %rax
leaq -0x80(%rbp), %rsi
movq %rax, 0x28(%rsi)
movq %rbx, %rdi
callq 0x2662
movsd %xmm0, -0x20(%rbp)
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2618
callq 0x21c0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2626
callq 0x21c0
movsd -0x20(%rbp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x264c
callq 0x21c0
jmp 0x264c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x265a
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rsi)
je 0x36e3
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x18(%rsi)
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq %rax, %rcx
testq %rdx, %rdx
jle 0x3683
movq %rax, %rcx
movq %rdx, %rsi
shrq %rsi
xorps %xmm1, %xmm1
cvtsi2sdq (%rcx,%rsi,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x367b
leaq (%rcx,%rsi,8), %rcx
addq $0x8, %rcx
notq %rsi
addq %rdx, %rsi
movq %rsi, %rdx
testq %rsi, %rsi
jg 0x365b
subq %rax, %rcx
shrq $0x3, %rcx
movq 0x38(%r14), %rax
imulq $0xc8, %rcx, %rcx
leaq (%rax,%rcx), %r14
cmpb $0x1, (%rax,%rcx)
jne 0x36b0
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7278
jmp 0x36db
movq 0x8(%r14), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
callq 0x4742
movq 0x30(%r14), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
cmpq %rdi, 0x40(%rbx)
je 0x3745
movl $0x38, %r14d
xorl %r15d, %r15d
movabsq $-0x70a3d70a3d70a3d7, %r12 # imm = 0x8F5C28F5C28F5C29
cmpb $0x1, -0x38(%rdi,%r14)
jne 0x3745
addq %r14, %rdi
callq 0x6dd4
incq %r15
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0xc8, %r14
cmpq %rax, %r15
jne 0x3713
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x2a0(%rbp), %rdi
callq 0x2140
leaq -0x290(%rbp), %r14
leaq 0x78e6(%rip), %rsi      # 0xb068
movl $0x1, %edx
movq %r14, %rdi
callq 0x2200
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x21d0
leaq 0x78c8(%rip), %rsi      # 0xb06a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2200
movq %r15, -0x30(%rbp)
movq 0x38(%rbx), %r15
movq 0x40(%rbx), %rbx
cmpq %rbx, %r15
je 0x38f7
leaq -0xf8(%rbp), %r12
leaq -0xe0(%rbp), %r13
movb (%r15), %al
movb %al, -0x118(%rbp)
movq 0x8(%r15), %rax
movq %rax, -0x110(%rbp)
movq %r12, -0x108(%rbp)
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
addq %rsi, %rdx
leaq -0x108(%rbp), %rdi
callq 0x4742
movq 0x30(%r15), %rax
movq %rax, -0xe8(%rbp)
addq $0x38, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x4340
movl $0x6, %edx
movq %r14, %rdi
leaq 0x789e(%rip), %rsi      # 0xb0cb
callq 0x2200
leaq -0x50(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x6030
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r14, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7d0b(%rip), %rsi      # 0xb56c
callq 0x2200
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3878
callq 0x21c0
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3886
callq 0x21c0
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x3894
callq 0x21c0
leaq -0xa0(%rbp), %rdi
callq 0x49e2
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x38bd
leaq -0xc0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0xd0(%rbp), %rax
testq %rax, %rax
je 0x38d6
movq %r13, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq *%rax
movq -0x108(%rbp), %rdi
cmpq %r12, %rdi
je 0x38e7
callq 0x21c0
addq $0x90, %r15
cmpq %rbx, %r15
jne 0x37d2
leaq 0x7c6e(%rip), %rsi      # 0xb56c
movl $0x1, %edx
movq %r14, %rdi
callq 0x2200
movq -0x30(%rbp), %rbx
leaq -0x288(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0xc693(%rip), %rsi      # 0xffb8
leaq -0x2a0(%rbp), %rdi
callq 0x2170
leaq -0x220(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x395e
jmp 0x3956
movq %rax, %rdi
callq 0x4733
movq %rax, %rbx
jmp 0x399f
movq %rax, %rbx
movq -0x108(%rbp), %rdi
cmpq %r12, %rdi
je 0x399f
callq 0x21c0
jmp 0x399f
movq %rax, %rbx
jmp 0x3993
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3993
callq 0x21c0
leaq -0x118(%rbp), %rdi
callq 0x4554
movq 0xc612(%rip), %rsi      # 0xffb8
leaq -0x2a0(%rbp), %rdi
callq 0x2170
leaq -0x220(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rsi, -0x38(%rbp)
callq 0x39c6
leaq 0x8(%rbx), %rax
movl $0x0, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, -0x30(%rbp)
movq %rcx, 0x28(%rbx)
movq 0x18(%r15), %r15
leaq -0xb0(%rbp), %rax
cmpq %rax, %r15
je 0x3e6d
leaq -0x50(%rbp), %rbx
leaq -0x88(%rbp), %r13
movq %rbx, %r12
movq %rbx, -0x60(%rbp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x4742
movq 0x40(%r15), %rbx
movq %rbx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x58(%rax), %r14
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4742
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x669e
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
movq %r12, %rbx
je 0x3e44
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3e52
callq 0x21c0
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
leaq -0xb0(%rbp), %rax
cmpq %rax, %r15
jne 0x3dbe
leaq -0xb8(%rbp), %rdi
callq 0x5232
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3ebf
movq %rax, %r14
jmp 0x3eb1
movq %rax, %r14
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3eb1
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3ebf
callq 0x21c0
movq -0x30(%rbp), %rdi
callq 0x52c6
leaq -0xb8(%rbp), %rdi
callq 0x5232
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x190(%rbp), %r15
leaq 0x5040(%rip), %rsi      # 0xb0d2
movl $0x1, %edx
movq %r15, %rdi
callq 0x2200
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2200
leaq 0x501e(%rip), %rsi      # 0xb0d4
movl $0x1, %edx
movq %r15, %rdi
callq 0x2200
movq (%r14), %rsi
movq %r15, %rdi
callq 0x21d0
leaq 0x5324(%rip), %rsi      # 0xb3f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0x9ec0(%rip), %rsi      # 0xffb8
leaq -0x1a0(%rbp), %rdi
callq 0x2170
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x9e8d(%rip), %rsi      # 0xffb8
leaq -0x1a0(%rbp), %rdi
callq 0x2170
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rdx, -0x18(%r14)
callq 0x20f0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x4742
movq -0x28(%rbp), %rax
leaq -0x80(%rbp), %rsi
movq %rax, 0x28(%rsi)
movq (%rsi), %rax
addq %rax, 0x58(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x777a
movq -0x80(%rbp), %r12
movq -0x78(%rbp), %rdi
movq 0x58(%rbx), %rbx
cmpq %r15, %rdi
je 0x6d4d
callq 0x21c0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x6d5b
callq 0x21c0
cvtsi2sd %r12, %xmm0
cvtsi2sd %rbx, %xmm1
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x6d8c
callq 0x21c0
jmp 0x6d8c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x6d9a
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
addq %rax, 0x58(%rdi)
addq $0x40, %rdi
callq 0x777a
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x58(%r14), %xmm1
divsd %xmm1, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x7272
movq %rdi, %rbx
callq *0x18(%rdi)
movsd %xmm0, -0x10(%rbp)
callq 0x22a0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x4025(%rip), %xmm0     # 0xb240
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
movq %rax, %xmm0
punpckldq 0x3de9(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3df1(%rip), %xmm0     # 0xb030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
subsd %xmm1, %xmm2
movq 0x78(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
ucomisd %xmm2, %xmm0
jae 0x726b
movq 0x60(%rbx), %rcx
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x73b8
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x3f31(%rip), %r15      # 0xb248
leaq -0x60(%rbp), %r13
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm1
movsd %xmm1, -0x58(%rbp)
divsd %xmm1, %xmm0
callq 0x2190
movapd %xmm0, %xmm2
movq %r15, %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movb $0x3, %al
callq 0x2040
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq (%rbx), %rax
divsd (%rax,%r12,8), %xmm0
callq 0x2190
movq (%r14), %rax
mulsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x7392
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x739e
leaq -0x50(%rbp), %rdi
movq %r13, %rdx
callq 0x78ee
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jne 0x731b
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
xorpd %xmm0, %xmm0
cmpq %rax, %rdi
je 0x73d9
movq %rdi, %rcx
addsd (%rcx), %xmm0
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x73cc
testq %rdi, %rdi
je 0x73ed
movsd %xmm0, -0x30(%rbp)
callq 0x21c0
movsd -0x30(%rbp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x740d
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl $0x90, %edx
xorl %esi, %esi
callq 0x2100
movq 0x40(%r14), %r13
movq %r14, -0x30(%rbp)
movq 0x48(%r14), %rax
leaq 0x40(%rbx), %r12
subq %r13, %rax
testq %rax, %rax
jle 0x7480
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x777a
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
jg 0x7468
movq 0x40(%r15), %r13
movq 0x48(%r15), %rax
subq %r13, %rax
testq %rax, %rax
jle 0x74bf
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x777a
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
jg 0x74a7
movq 0x58(%r15), %rax
movq -0x30(%rbp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x4468
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x90, %edx
xorl %esi, %esi
callq 0x2100
movq 0x40(%r14), %r13
movq %r14, -0x30(%rbp)
movq 0x48(%r14), %rax
leaq 0x40(%rbx), %r12
subq %r13, %rax
testq %rax, %rax
jle 0x7560
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x777a
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
jg 0x7548
movq 0x40(%r15), %r13
movq 0x48(%r15), %rax
subq %r13, %rax
testq %rax, %rax
jle 0x759f
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x777a
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
jg 0x7587
movq 0x58(%r15), %rax
movq -0x30(%rbp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x75c3
movq %rax, %r14
movq %rbx, %rdi
callq 0x4468
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x208(%rbp), %rdi
callq 0x2140
leaq -0x1f8(%rbp), %rdi
leaq 0x3a5e(%rip), %rsi      # 0xb068
movl $0x1, %edx
callq 0x2200
movq 0x58(%r15), %rsi
leaq -0x1f8(%rbp), %rdi
callq 0x21d0
leaq 0x3c36(%rip), %rsi      # 0xb261
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq %rbx, -0x30(%rbp)
movq 0x40(%r15), %r14
movq 0x48(%r15), %r15
cmpq %r15, %r14
je 0x76c4
leaq -0x68(%rbp), %rbx
leaq -0x50(%rbp), %r12
leaq -0x80(%rbp), %r13
movq (%r14), %rax
movq %rax, -0x80(%rbp)
movq %rbx, -0x78(%rbp)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x4742
movq 0x28(%r14), %rax
movq %rax, -0x58(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x6062
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x1f8(%rbp), %rdi
callq 0x2200
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x76ad
callq 0x21c0
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x76bb
callq 0x21c0
addq $0x30, %r14
cmpq %r15, %r14
jne 0x7655
leaq 0x3b98(%rip), %rsi      # 0xb263
movl $0x1, %edx
leaq -0x1f8(%rbp), %rdi
callq 0x2200
movq -0x30(%rbp), %rbx
leaq -0x1f0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0x88c2(%rip), %rsi      # 0xffb8
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7725
movq %rax, %r14
jmp 0x7752
movq %rax, %r14
jmp 0x7744
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7744
callq 0x21c0
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x7752
callq 0x21c0
movq 0x885f(%rip), %rsi      # 0xffb8
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x5d2b(%rip), %rbx      # 0xffd0
leaq 0x1290(%rip), %rsi      # 0xb53c
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
leaq 0x1284(%rip), %r14      # 0xb544
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x7fd0
leaq 0x1292(%rip), %rsi      # 0xb56e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x82c0
leaq 0x1271(%rip), %rsi      # 0xb576
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x8a0e
leaq 0x1250(%rip), %rsi      # 0xb57e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x921a
leaq 0x122f(%rip), %rsi      # 0xb586
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x94f0
leaq 0x120e(%rip), %rsi      # 0xb58e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x9b8e
leaq 0x11ed(%rip), %rsi      # 0xb596
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x9fe2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq