LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/CastellanZhang[P]lambdaFM/src/Frame/pc_frame.cpp
// Function: pc_frame::conThread()
void pc_frame::conThread()
{
    bool finished_flag = false;
    vector<vector<fm_sample> > input_vec;
    while(true)
    {
        input_vec.clear();
        sem_wait(&semCon);
        bufMtx.lock();
        for(int i = 0; i < bufSize;)
        {
            if(buffer.empty())
            {
                finished_flag = true;
                break;
            }
            input_vec.push_back(buffer.front());
            i += buffer.front().size();
            buffer.pop();
        }
        bufMtx.unlock();
        sem_post(&semPro);
        pTask->run_task(input_vec);
        if(finished_flag)
            break;
    }
    sem_post(&semCon);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rdi), %r12
leaq 0x78(%rdi), %r13
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r12
cmpq %rbp, %r12
je 0x6742
movq %rbp, %r15
movq %r15, %rdi
callq 0x5916
addq $0x18, %r15
cmpq %r12, %r15
jne 0x672c
movq %rbp, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3170
movq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x3370
testl %eax, %eax
jne 0x6801
xorl %ebp, %ebp
cmpl $0x0, 0xe0(%rbx)
jle 0x67b4
movq 0x88(%rbx), %rsi
cmpq %rsi, 0xa8(%rbx)
sete %r15b
je 0x67b7
movq %r14, %rdi
callq 0x6da0
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
addl %eax, %ebp
movq %r13, %rdi
callq 0x7f3a
cmpl 0xe0(%rbx), %ebp
jl 0x676c
jmp 0x67b7
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x31d0
movq 0x28(%rsp), %rdi
callq 0x33f0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
testb %r15b, %r15b
je 0x671a
movq 0x8(%rsp), %rdi
callq 0x33f0
leaq 0x10(%rsp), %rdi
callq 0x6dcc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3190
jmp 0x680c
jmp 0x680c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6dcc
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/CastellanZhang[P]lambdaFM/src/Utils/utils.cpp
// Function: utils::gaussian()
double utils::gaussian() 
{
    double u,v, x, y, Q;
    do
    {
        do 
        {
            u = uniform();
        } while (u == 0.0); 

        v = 1.7156 * (uniform() - 0.5);
        x = u - 0.449871;
        y = fabs(v) + 0.386595;
        Q = x * x + y * (0.19600 * y - 0.25472 * x);
    } while (Q >= 0.27597 && (Q > 0.27846 || v * v > -4.0 * u * u * log(u)));
    return v / u;
}

// Assembly:
subq $0x38, %rsp
callq 0x3080
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x12ea(%rip), %xmm0     # 0x93a8
ucomisd 0x11ea(%rip), %xmm0     # 0x92b0
jne 0x80ca
jnp 0x80aa
movsd %xmm0, (%rsp)
callq 0x3080
movsd (%rsp), %xmm4
xorps %xmm5, %xmm5
cvtsi2sd %eax, %xmm5
mulsd 0x12c0(%rip), %xmm5     # 0x93a8
addsd 0x12c0(%rip), %xmm5     # 0x93b0
mulsd 0x12c0(%rip), %xmm5     # 0x93b8
movapd %xmm4, %xmm0
addsd 0x12bc(%rip), %xmm0     # 0x93c0
movapd %xmm5, %xmm1
andpd 0x12f0(%rip), %xmm1     # 0x9400
addsd 0x12b0(%rip), %xmm1     # 0x93c8
movapd %xmm0, %xmm2
mulsd 0x12ac(%rip), %xmm2     # 0x93d0
movapd %xmm1, %xmm3
mulsd 0x12a8(%rip), %xmm3     # 0x93d8
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd 0x1298(%rip), %xmm0     # 0x93e0
jb 0x81ac
ucomisd 0x1296(%rip), %xmm0     # 0x93e8
ja 0x80aa
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
movapd %xmm0, 0x10(%rsp)
movapd %xmm4, %xmm0
mulsd 0x127e(%rip), %xmm0     # 0x93f0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm4, %xmm0
movapd %xmm5, 0x20(%rsp)
callq 0x3200
movapd 0x20(%rsp), %xmm5
movsd (%rsp), %xmm4
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x80aa
divsd %xmm4, %xmm5
movapd %xmm5, %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/examples/ex_iter.cpp
// Function: main
int main(int argc, char **argv)
{
    const char *fname = argv[1];

    auto bt = BTree::Open(fname);
    if (bt == NULL)
    {
        printf("open db[%s] failed", fname);
        return -1;
    }

    /*
    bt->Put("name1", "tom");
    bt->Put("name2", "jack");
    bt->Put("name3", "michael");
    bt->Put("greet", "hello world");
    */

    auto iter = bt->NewIterator();
    for (iter->SeekToFirst(); iter->Valid(); iter->Next())
    {
        // std::cout << iter->Key() << ": " << iter->Value() << std::endl;
        std::cout << iter->Key() << std::endl;
    }
    delete iter;
    bt->Close();
    delete bt;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x8(%rsi), %r14
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movq %r14, %rsi
callq 0x20c0
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq 0x30f(%rip), %rax       # 0x28b4
movq %rax, 0x18(%rsi)
leaq 0x30e(%rip), %rax       # 0x28be
movq %rax, 0x10(%rsi)
leaq -0x90(%rbp), %rdi
movl $0x2, %edx
callq 0x33d4
movq %rax, %rbx
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x25df
leaq -0x70(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25f1
callq 0x21b0
testq %rbx, %rbx
je 0x26ef
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x34fe
movq %rax, %r14
movq %rax, %rdi
callq 0x2944
movq %r14, %rdi
callq 0x3046
testb %al, %al
je 0x2693
leaq -0x40(%rbp), %rbx
leaq -0x50(%rbp), %r15
movq 0x99ac(%rip), %r12      # 0xbfd8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3050
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r12, %rdi
callq 0x2230
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x267f
callq 0x21b0
movq %r14, %rdi
callq 0x2d68
movq %r14, %rdi
callq 0x3046
testb %al, %al
jne 0x262c
movq %r14, %rdi
addq $0x8, %rdi
callq 0x27f8
movq %r14, %rdi
callq 0x21b0
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x34f4
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x26c1
callq 0x277e
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x26db
movq %rbx, %rdi
addq $0x50, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x284e
movq %rbx, %rdi
callq 0x21b0
xorl %eax, %eax
jmp 0x2705
leaq 0x590e(%rip), %rdi      # 0x8004
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2741
jmp 0x2741
movq %rax, %r14
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x2732
leaq -0x70(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x275a
jmp 0x275f
movq %rax, %rdi
callq 0x27ea
movq %rax, %r14
jmp 0x275f
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x275f
callq 0x21b0
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/./btree.h
// Function: fishdb::DefaultCmp::operator()(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>> const&)
bool operator()(const std::string &a, const std::string &b)
    {
        int min_len = std::min(a.length(), b.length());
        if (min_len == 0) return false;
        int result = memcmp(a.data(), b.data(), min_len);
        if (result != 0) return result < 0;
        return a.length() < b.length();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rbx
movq 0x8(%rdx), %r14
cmpq %rbx, %r14
movq %rbx, %rax
cmovbq %r14, %rax
testl %eax, %eax
je 0x2910
movq (%rsi), %rdi
movq (%rdx), %rsi
movslq %eax, %rdx
callq 0x20e0
testl %eax, %eax
je 0x2914
shrl $0x1f, %eax
jmp 0x291a
xorl %eax, %eax
jmp 0x291a
cmpq %r14, %rbx
setb %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/./iter.cpp
// Function: fishdb::Iterator::SeekToFirst()
void Iterator::SeekToFirst()
{
    auto now = m_btree->m_root;
    m_stack.push_back(now);

    while (!now->is_leaf)
    {
        now = m_btree->ReadPage(now->children[0]);
        m_stack.push_back(now);
    }
    if (now->kvs.size() > 0)
    {
        m_valid = true;
        m_kv_idx = 0;
    }
    else
    {
        m_valid = false;
        m_stack.clear();
    }
    printf("iter stack_size[%zu]\n", m_stack.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x70(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x2983
movq 0x965b(%rip), %rcx      # 0xbfd0
cmpb $0x0, (%rcx)
je 0x297f
incl 0x8(%rax)
jmp 0x2983
lock
incl 0x8(%rax)
leaq 0x8(%rbx), %r14
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x311a
leaq -0x40(%rbp), %r15
leaq -0x30(%rbp), %r12
movq -0x30(%rbp), %rax
cmpb $0x0, 0x79(%rax)
jne 0x29ef
movq (%rbx), %rsi
movq 0x48(%rax), %rax
movq (%rax), %rdx
movq %r15, %rdi
callq 0x353c
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movups %xmm0, -0x30(%rbp)
testq %rdi, %rdi
je 0x29e2
callq 0x277e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x29e2
callq 0x277e
movq %r14, %rdi
movq %r12, %rsi
callq 0x311a
jmp 0x299b
movq 0x68(%rax), %rcx
cmpq 0x60(%rax), %rcx
je 0x2a06
movb $0x1, 0x24(%rbx)
movl $0x0, 0x20(%rbx)
jmp 0x2a12
movb $0x0, 0x24(%rbx)
movq %r14, %rdi
callq 0x3168
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x4, %rsi
leaq 0x561b(%rip), %rdi      # 0x8040
xorl %eax, %eax
callq 0x2050
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2a3a
callq 0x277e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a4b
jmp 0x2a4b
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2a5c
callq 0x277e
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/./iter.cpp
// Function: fishdb::Iterator::SeekToLast()
void Iterator::SeekToLast()
{
    auto now = m_btree->m_root;
    m_stack.push_back(now);

    while (!now->is_leaf)
    {
        now = m_btree->ReadPage(now->children.back());
        m_stack.push_back(now);
    }
    if (now->kvs.size() > 0)
    {
        m_valid = true;
        m_kv_idx = now->kvs.size() - 1;
    }
    else
    {
        m_valid = false;
        m_stack.clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x70(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x2aa3
movq 0x953b(%rip), %rcx      # 0xbfd0
cmpb $0x0, (%rcx)
je 0x2a9f
incl 0x8(%rax)
jmp 0x2aa3
lock
incl 0x8(%rax)
leaq 0x8(%rbx), %r14
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x311a
leaq -0x40(%rbp), %r15
leaq -0x30(%rbp), %r12
movq -0x30(%rbp), %rcx
cmpb $0x0, 0x79(%rcx)
jne 0x2b10
movq (%rbx), %rsi
movq 0x50(%rcx), %rax
movq -0x8(%rax), %rdx
movq %r15, %rdi
callq 0x353c
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movups %xmm0, -0x30(%rbp)
testq %rdi, %rdi
je 0x2b03
callq 0x277e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2b03
callq 0x277e
movq %r14, %rdi
movq %r12, %rsi
callq 0x311a
jmp 0x2abb
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
je 0x2b29
shrq $0x6, %rax
movb $0x1, 0x24(%rbx)
decl %eax
movl %eax, 0x20(%rbx)
jmp 0x2b35
movb $0x0, 0x24(%rbx)
movq %r14, %rdi
callq 0x3168
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2b43
callq 0x277e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b54
jmp 0x2b54
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2b65
callq 0x277e
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/./btree.cpp
// Function: fishdb::BTree::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (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>> const&)>, int)
BTree * BTree::Open(std::string dbfile,
        CmpFunc cmp_func, int min_key_num)
{
    BTree *bt = new BTree();
    bt->m_cmp_func = cmp_func;
    bt->m_min_key_num = min_key_num;

    int ret = bt->m_pager.Init(dbfile);
    if (ret)
        return NULL;
    bt->m_root = bt->m_pager.GetRoot();
    printf("root_page_no[%" PRId64 "]\n", bt->m_root->header.page_no);
    return bt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x21f0
movq %rax, %rbx
addq $0x8, %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, (%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x40(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x50(%rbx), %rdi
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq %r15, %rsi
callq 0x4cee
movl %r14d, 0x48(%rbx)
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x31aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6054
movl %eax, %r14d
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3473
callq 0x21b0
testl %r14d, %r14d
je 0x347c
xorl %ebx, %ebx
jmp 0x34cb
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6396
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x78(%rbx), %rdi
movups %xmm0, 0x70(%rbx)
testq %rdi, %rdi
je 0x34b6
callq 0x277e
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x34b6
callq 0x277e
movq 0x70(%rbx), %rax
movq (%rax), %rsi
leaq 0x4c51(%rip), %rdi      # 0x8115
xorl %eax, %eax
callq 0x2050
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x34ec
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3646
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %r13
cmpq $0x0, 0x60(%r15)
je 0x3655
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *0x68(%r15)
testb %al, %al
je 0x3643
addq $0x40, %r12
movq (%r14), %rax
movq 0x68(%rax), %rax
cmpq %rax, %r12
jne 0x3619
jmp 0x3646
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_O3/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 0x36b2
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %r13
cmpq $0x0, 0x60(%r15)
je 0x36c1
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x68(%r15)
testb %al, %al
jne 0x36af
addq $0x40, %r12
movq (%r14), %rax
movq 0x68(%rax), %rax
cmpq %rax, %r12
jne 0x3685
jmp 0x36b2
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_O3/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 $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
movq 0x70(%rdi), %r15
movq 0x78(%rdi), %r14
testq %r14, %r14
je 0x3772
movq 0x886e(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x376d
incl 0x8(%r14)
jmp 0x3772
lock
incl 0x8(%r14)
testq %r15, %r15
je 0x3837
movq %rdx, -0x58(%rbp)
movq %r14, %rbx
movq %r15, -0x50(%rbp)
movq %r14, -0x48(%rbp)
testq %r14, %r14
je 0x37a4
movq 0x883a(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x37a0
incl 0x8(%rbx)
jmp 0x37a4
lock
incl 0x8(%rbx)
movq %r13, %rdi
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x35ee
movq %rax, %r12
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x37c5
callq 0x277e
movq %r12, %r14
subq 0x60(%r15), %r14
cmpq 0x68(%r15), %r12
je 0x37e5
movq %r13, %rdi
movq %r12, %rsi
movq -0x30(%rbp), %rdx
callq 0x359e
testb %al, %al
jne 0x384a
cmpb $0x0, 0x79(%r15)
jne 0x3842
movq 0x48(%r15), %rax
sarq $0x3, %r14
movq (%rax,%r14), %rdx
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x353c
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %rbx, %rbx
je 0x382e
movq %rbx, %rdi
callq 0x277e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x382e
callq 0x277e
testq %r15, %r15
jne 0x377f
movq %r14, %rbx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x385d
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x385d
addq $0x20, %r12
xorl %r14d, %r14d
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x2110
testq %rbx, %rbx
je 0x386a
movq %rbx, %rdi
callq 0x277e
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3880
jmp 0x3880
movq %rax, %r14
jmp 0x3896
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3896
callq 0x277e
testq %rbx, %rbx
je 0x38a3
movq %rbx, %rdi
callq 0x277e
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39c1(%rip), %rsi      # 0x8325
movl $0x1, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, -0x30(%rbp)
movq 0x60(%r14), %rax
cmpq %rax, 0x68(%r14)
je 0x49ec
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x3998(%rip), %rbx      # 0x8327
leaq 0x3791(%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 0x4996
leaq 0x3936(%rip), %rsi      # 0x8329
leaq -0x1a8(%rbp), %rdi
movl $0x1, %edx
callq 0x2230
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22d0
movq 0x75aa(%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 0x4a4d
movq %rax, %rbx
movq 0x7571(%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_O3/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 0x387d(%rip), %rsi      # 0x8325
movl $0x1, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, -0x30(%rbp)
movq 0x48(%r14), %rax
cmpq %rax, 0x50(%r14)
je 0x4b1d
xorl %r12d, %r12d
leaq 0x385a(%rip), %r13      # 0x8327
leaq 0x3653(%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 0x4ad4
leaq 0x3805(%rip), %rsi      # 0x8329
leaq -0x1a8(%rbp), %rdi
movl $0x1, %edx
callq 0x2230
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22d0
movq 0x7479(%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 0x4b7e
movq %rax, %rbx
movq 0x7440(%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_O3/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 0x4934
movq (%r12), %r12
movq (%rbx), %rdx
leaq -0x78(%rbp), %rdi
callq 0x4a78
leaq -0x68(%rbp), %r13
movq -0x10(%r13), %rcx
leaq 0x373b(%rip), %rdi      # 0x832b
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x4c0b
callq 0x21b0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c1d
callq 0x21b0
movq (%rbx), %rcx
movq 0x48(%rcx), %rax
cmpq %rax, 0x50(%rcx)
je 0x4c9b
xorl %r13d, %r13d
leaq -0x58(%rbp), %r15
leaq -0x38(%rbp), %r12
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x353c
movq (%rbx), %rax
movq 0x48(%rax), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x353c
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ba8
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4c73
callq 0x277e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4c81
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 0x4c35
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 0x4ce5
callq 0x21b0
jmp 0x4ce5
movq %rax, %rbx
jmp 0x4cd7
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4cd7
callq 0x277e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4ce5
callq 0x277e
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2314(%rip), %rsi      # 0x839d
callq 0x2250
movq %rax, 0x38(%rbx)
testq %rax, %rax
jne 0x60b3
movq (%r14), %rdi
leaq 0x2300(%rip), %rsi      # 0x83a1
callq 0x2250
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x616b
movq %rax, %rdi
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 0x6151
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 0x6164
movq 0x38(%rbx), %rcx
movl $0x18, %esi
movl $0x1, %edx
callq 0x22b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2233(%rip), %rdi      # 0x83a5
leaq 0x2233(%rip), %rsi      # 0x83ac
leaq 0x2238(%rip), %rcx      # 0x83b8
movl $0x10, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61de
movq 0x38(%rbx), %rdi
callq 0x21e0
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x18(%rdi), %r12
leaq 0x8(%rdi), %r14
cmpq %r14, %r12
je 0x6348
movl %esi, %r15d
movq %rdi, %rbx
cmpl %esi, 0x28(%rdi)
jle 0x6348
movq 0x28(%r12), %rax
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x6242
movq 0x5d99(%rip), %rcx      # 0xbfd0
cmpb $0x0, (%rcx)
je 0x6262
incl 0x8(%r13)
jmp 0x6267
movb 0x78(%rax), %cl
xorb $0x1, %cl
orb -0x2c(%rbp), %cl
cmpb $0x1, %cl
jne 0x62e0
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
jmp 0x6291
lock
incl 0x8(%r13)
movb 0x78(%rax), %cl
xorb $0x1, %cl
orb -0x2c(%rbp), %cl
je 0x62d8
movq %rax, -0x60(%rbp)
movq %r13, -0x58(%rbp)
movq 0x5d4f(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x628c
incl 0x8(%r13)
jmp 0x6291
lock
incl 0x8(%r13)
movq %rbx, %rdi
leaq -0x60(%rbp), %rsi
callq 0x69f0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x62ab
callq 0x277e
leaq 0x20(%r12), %rdx
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x62ca
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x62d3
leaq -0x50(%rbp), %rdi
callq 0x5a74
testq %r13, %r13
je 0x62e0
movq %r13, %rdi
callq 0x277e
movq %r12, %rdi
callq 0x2160
cmpq %r14, %rax
je 0x62fa
movq %rax, %r12
cmpl %r15d, 0x28(%rbx)
jg 0x6221
movq -0x50(%rbp), %rsi
cmpq %rsi, -0x48(%rbp)
je 0x633b
xorl %r14d, %r14d
xorl %r15d, %r15d
addq %r14, %rsi
movq %rbx, %rdi
callq 0x70c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x714c
incq %r15
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r14
cmpq %rax, %r15
jb 0x630a
testq %rsi, %rsi
je 0x6348
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 0x636d
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x636d
callq 0x277e
testq %r13, %r13
je 0x637f
movq %r13, %rdi
callq 0x277e
jmp 0x637f
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x638d
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63e7
xorl %ecx, %ecx
callq 0x65c8
movq (%rbx), %rax
movq (%rax), %rax
movq 0x30(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x6403
leaq 0x200e(%rip), %rdi      # 0x83dd
leaq 0x1fd6(%rip), %rsi      # 0x83ac
leaq 0x202d(%rip), %rcx      # 0x840a
movl $0x3d, %edx
callq 0x2140
movl $0x2, %edx
callq 0x640c
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_O3/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::NewPage(fishdb::PageType)
std::shared_ptr<MemPage> Pager::NewPage(PageType type)
{
    std::shared_ptr<MemPage> mp;
    if (m_db_header->free_list != -1)
    {
        mp = ReadPage(m_db_header->free_list);
        m_db_header->free_list = mp->header.next_free;
    }
    else
    {
        mp = std::make_shared<MemPage>();
        mp->header.page_no = m_db_header->total_pages++;
    }
    // init page
    auto &header = mp->header;
    header.type = type;
    header.next_free = -1;
    header.of_page_no = -1;
    header.data_size = 0;
    header.page_cnt = 1;
    header.is_leaf = true;

    if (type == TREE_PAGE &&
            m_pages.find(mp->header.page_no) == m_pages.end())
        CachePage(mp);

    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq 0x30(%rsi), %rax
movq (%rax), %rdx
cmpq $-0x1, %rdx
je 0x6464
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x67a6
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %r15
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq 0x30(%r14), %rax
movq 0x10(%r12), %rcx
movq %rcx, (%rax)
jmp 0x64d8
movl $0xa0, %edi
callq 0x21f0
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x58ba(%rip), %rax      # 0xbd40
movq %rax, (%r15)
leaq 0x10(%r15), %r12
movl $0x90, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2120
movq %r15, %rax
addq $0x48, %rax
movq %rax, 0x38(%r15)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x58(%r15)
movdqu %xmm0, 0x68(%r15)
movdqu %xmm0, 0x78(%r15)
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq 0x30(%r14), %rax
movq 0x10(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, 0x10(%r15)
movb %r13b, 0x8(%r12)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%r12)
movl $0x0, 0x20(%r12)
movw $0x1, 0x24(%r12)
movb $0x1, 0x26(%r12)
cmpl $0x2, %r13d
jne 0x657a
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x653c
leaq 0x8(%r14), %rsi
movq (%r12), %rcx
movq %rsi, %rdx
xorl %edi, %edi
cmpq %rcx, 0x20(%rax)
setl %dil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x6519
cmpq %rsi, %rdx
je 0x653c
cmpq 0x20(%rdx), %rcx
jge 0x657a
movq %r12, -0x38(%rbp)
movq %r15, -0x30(%rbp)
testq %r15, %r15
je 0x6560
movq 0x5a80(%rip), %rax      # 0xbfd0
cmpb $0x0, (%rax)
je 0x655b
incl 0x8(%r15)
jmp 0x6560
lock
incl 0x8(%r15)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x6980
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x657a
callq 0x277e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65a1
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x65a4
callq 0x277e
jmp 0x65a4
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x65b2
callq 0x277e
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::ReadPage(long)
std::shared_ptr<MemPage> Pager::ReadPage(int64_t page_no)
{
    char buf[PG_SIZE * 2];
    // if page_no invalid, return nil
    if (page_no <= 0) return nil;
    int64_t offset = page_no * PG_SIZE;
    if (offset + PG_SIZE > m_file_size) return nil;

    auto mp = std::make_shared<MemPage>();
    auto header = &mp->header;
    fseek(m_file, offset, SEEK_SET);
    fread((void *)header, sizeof(PageHeader), 1, m_file);
    fread((void *)buf, PAGE_CAPA, 1, m_file);
    mp->Feed(buf, PAGE_CAPA);
    if (mp->header.page_no != page_no)
    {
        auto p = std::make_shared<MemPage>();
        p->header.page_no = page_no;
        p->header.page_cnt = 1;
        p->header.of_page_no = -1;
        p->header.next_free = -1;
        return p;
    }
    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x67dc
movq %rdx, %r12
movq %rsi, %r13
movq %rdx, %r14
shlq $0x9, %r14
leaq 0x200(%r14), %rax
cmpq 0x40(%rsi), %rax
jle 0x6812
movq 0x5a0d(%rip), %rax      # 0xc1f0
movq %rax, (%rbx)
movq 0x5a0b(%rip), %rax      # 0xc1f8
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6957
movq 0x57cf(%rip), %rcx      # 0xbfd0
cmpb $0x0, (%rcx)
je 0x68d3
incl 0x8(%rax)
jmp 0x6957
movl $0xa0, %edi
callq 0x21f0
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x550c(%rip), %rax      # 0xbd40
movq %rax, (%r15)
leaq 0x10(%r15), %rdi
movq %rdi, -0x30(%rbp)
movl $0x90, %edx
xorl %esi, %esi
callq 0x2120
leaq 0x48(%r15), %rax
movq %rax, 0x38(%r15)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x58(%r15)
movdqu %xmm0, 0x68(%r15)
movdqu %xmm0, 0x78(%r15)
movq 0x38(%r13), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2220
movq 0x38(%r13), %rcx
movl $0x28, %esi
movl $0x1, %edx
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x22b0
movq 0x38(%r13), %rcx
movq %r14, %r13
leaq -0x430(%rbp), %r14
movl $0x1d8, %esi            # imm = 0x1D8
movl $0x1, %edx
movq %r14, %rdi
callq 0x22b0
movq %r13, %rdi
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x73d2
cmpq %r12, (%r13)
jne 0x68d9
movq %r13, (%rbx)
movq %r15, 0x8(%rbx)
jmp 0x6957
lock
incl 0x8(%rax)
jmp 0x6957
movl $0xa0, %edi
callq 0x21f0
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x5445(%rip), %rax      # 0xbd40
movq %rax, (%r14)
leaq 0x10(%r14), %r13
leaq 0x18(%r14), %rdi
movl $0x88, %edx
xorl %esi, %esi
callq 0x2120
movq %r14, %rax
addq $0x48, %rax
movq %rax, 0x38(%r14)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x58(%r14)
movdqu %xmm0, 0x68(%r14)
movdqu %xmm0, 0x78(%r14)
movq %r14, 0x8(%rbx)
movq %r13, (%rbx)
movq %r12, 0x10(%r14)
movw $0x1, 0x34(%r14)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x20(%r14)
movq %r15, %rdi
callq 0x277e
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x277e
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %r15, %rax
cmpq 0x40(%rdi), %r13
jle 0x6d23
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 0x6d84
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 0x176f(%rip), %rdi      # 0x84fa
leaq 0x161a(%rip), %rsi      # 0x83ac
leaq 0x177e(%rip), %rcx      # 0x8517
movl $0xdc, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x775e
cltq
movq %rbx, -0x30(%rbp)
leaq (%rbx,%rax), %r12
addq $0x28, %r12
movq 0x48(%r15), %rax
cmpq %rax, 0x50(%r15)
je 0x7478
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
callq 0x776b
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 0x744a
jmp 0x747b
movq %r12, %r13
movq 0x68(%r15), %rsi
subq 0x60(%r15), %rsi
shrq $0x6, %rsi
movq %r13, %rdi
callq 0x775e
movslq %eax, %r12
addq %r13, %r12
movq 0x60(%r15), %rsi
cmpq %rsi, 0x68(%r15)
je 0x74ea
xorl %ebx, %ebx
xorl %r14d, %r14d
addq %rbx, %rsi
movq %r12, %rdi
callq 0x7779
movslq %eax, %r13
addq %r12, %r13
movq 0x60(%r15), %rax
leaq (%rax,%rbx), %rsi
addq $0x20, %rsi
movq %r13, %rdi
callq 0x7779
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 0x74a4
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_O3/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 0x4cd6(%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 0x77d0
movslq %eax, %r14
addq %r15, %r14
cmpl $0x0, (%r12)
jle 0x75af
leaq 0x48(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r15d, %r15d
leaq -0xb8(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x77df
movl %eax, %r13d
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x7594
movq -0xb8(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x75a0
movq -0x38(%rbp), %rdi
movq %r12, %rdx
callq 0x5a74
movslq %r13d, %rax
addq %rax, %r14
incl %r15d
cmpl -0x2c(%rbp), %r15d
jl 0x7568
movq %rbx, -0x38(%rbp)
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x77d0
cmpl $0x0, (%r15)
jle 0x76a5
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 0x77f0
leaq -0x78(%rbp), %r12
cltq
addq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x77f0
movl %eax, %r15d
movq %rbx, %rdi
leaq -0x58(%rbp), %rsi
movq %r12, %rdx
callq 0x4d62
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x76fa
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x7656
callq 0x21b0
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rax
cmpq %rax, %rdi
je 0x766e
callq 0x21b0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x7680
callq 0x21b0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7692
callq 0x21b0
movslq %r15d, %rax
addq %rax, %r14
incl %r13d
cmpl -0x2c(%rbp), %r13d
jl 0x75e0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76ca
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x4dca
jmp 0x76cd
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x76df
callq 0x21b0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x76f1
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x784c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x783b
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_O3/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 0x32aa
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x18(%rsi)
movq 0x20(%r14), %rax
movq 0x28(%r14), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movq %rax, %rcx
testq %rsi, %rsi
jle 0x324a
movq %rsi, %rdx
shrq %rdx
xorps %xmm1, %xmm1
cvtsi2sdq (%rcx,%rdx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3242
leaq (%rcx,%rdx,8), %rcx
addq $0x8, %rcx
notq %rdx
addq %rsi, %rdx
movq %rdx, %rsi
testq %rdx, %rdx
jg 0x3222
subq %rax, %rcx
shrq $0x3, %rcx
movq 0x38(%r14), %rax
imulq $0xc8, %rcx, %rcx
leaq (%rax,%rcx), %r14
cmpb $0x1, (%rax,%rcx)
jne 0x3277
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e34
jmp 0x32a2
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 0x4420
movq 0x30(%r14), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x330d
movl $0x38, %r14d
xorl %r15d, %r15d
movabsq $-0x70a3d70a3d70a3d7, %r12 # imm = 0x8F5C28F5C28F5C29
cmpb $0x1, -0x38(%rdi,%r14)
jne 0x330d
addq %r14, %rdi
callq 0x6984
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 0x32db
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq