LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_predictor.h
// Function: ftrl_predictor::ftrl_predictor(double, std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
ftrl_predictor::ftrl_predictor(double _factor_num, ifstream& _fModel, ofstream& _fPredict):fPredict(_fPredict)
{
    pModel = new ftrl_model(_factor_num);
    if(!pModel->loadModel(_fModel))
    {
        cout << "load model error!" << endl;
        exit(-1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
leaq 0x911c(%rip), %rax      # 0xcd08
movq %rax, (%rdi)
movq %rdx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
pushq $0x78
popq %rdi
callq 0x3270
movq %rax, %r15
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x367c
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ab8
testb %al, %al
je 0x3c39
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x9378(%rip), %rdi      # 0xcfb8
leaq 0x43dd(%rip), %rsi      # 0x8024
callq 0x3260
movq %rax, %rdi
callq 0x3110
pushq $-0x1
popq %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/lambdafm_predict.cpp
// Function: argv_to_args[abi:cxx11](int, char**)
vector<string> argv_to_args(int argc, char* argv[])
{
    vector<string> args;
    for(int i = 1; i < argc; ++i)
    {
        args.push_back(string(argv[i]));
    }
    return args;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movslq %esi, %r13
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
cmpq %r13, %rbp
jge 0x3f82
movq (%r14,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x30c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a8e
movq %r15, %rdi
callq 0x3458
incq %rbp
jmp 0x3f56
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3458
jmp 0x3fa6
movq %rax, %r14
movq %rbx, %rdi
callq 0x480e
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model_unit::ftrl_model_unit(int, double, double)
ftrl_model_unit(int factor_num, double v_mean, double v_stdev)
    {
        wi = 0.0;
        w_ni = 0.0;
        w_zi = 0.0;
        vi.resize(factor_num);
        v_ni.resize(factor_num);
        v_zi.resize(factor_num);
        for(int f = 0; f < factor_num; ++f)
        {
            vi[f] = utils::gaussian(v_mean, v_stdev);
            v_ni[f] = 0.0;
            v_zi[f] = 0.0;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %r12d
leaq 0x18(%rdi), %rbx
leaq 0x30(%rdi), %r14
leaq 0x48(%rdi), %r15
movslq %esi, %r13
movl $0x88, %edx
xorl %esi, %esi
callq 0x3150
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4a3c
movq %r14, %rdi
movq %r13, %rsi
callq 0x4a3c
movq %r15, %rdi
movq %r13, %rsi
callq 0x4a3c
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x4544
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x77f4
movq (%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
movq (%r14), %rax
andq $0x0, (%rax,%r13,8)
movq (%r15), %rax
andq $0x0, (%rax,%r13,8)
incq %r13
jmp 0x4511
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4554
movq %rax, %r12
movq %r15, %rdi
callq 0x4c1c
movq %r14, %rdi
callq 0x4c1c
movq %rbx, %rdi
callq 0x4c1c
movq %r12, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: operator<<(std::ostream&, ftrl_model_unit const&)
inline ostream& operator <<(ostream& os, const ftrl_model_unit& mu)
    {
        os << mu.wi;
        for(int f = 0; f < mu.vi.size(); ++f)
        {
            os << " " << mu.vi[f];
        }
        os << " " << mu.w_ni << " " << mu.w_zi;
        for(int f = 0; f < mu.v_ni.size(); ++f)
        {
            os << " " << mu.v_ni[f];
        }
        for(int f = 0; f < mu.v_zi.size(); ++f)
        {
            os << " " << mu.v_zi[f];
        }
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x3380
xorl %r12d, %r12d
leaq 0x3a87(%rip), %r15      # 0x8020
movq 0x20(%r14), %r13
subq 0x18(%r14), %r13
sarq $0x3, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3260
cmpq %r12, %r13
jbe 0x45cc
movq 0x18(%r14), %rcx
movsd (%rcx,%r12,8), %xmm0
movq %rax, %rdi
callq 0x3380
incq %r12
jmp 0x4599
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x3380
leaq 0x3a3f(%rip), %r15      # 0x8020
movq %rax, %rdi
movq %r15, %rsi
callq 0x3260
movsd 0x10(%r14), %xmm0
movq %rax, %rdi
callq 0x3380
xorl %r12d, %r12d
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x4630
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3260
movq 0x30(%r14), %rcx
movsd (%rcx,%r12,8), %xmm0
movq %rax, %rdi
callq 0x3380
incq %r12
jmp 0x45fd
xorl %r12d, %r12d
leaq 0x39e6(%rip), %r15      # 0x8020
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x466d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3260
movq 0x48(%r14), %rcx
movsd (%rcx,%r12,8), %xmm0
movq %rax, %rdi
callq 0x3380
incq %r12
jmp 0x463a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_model.h
// Function: ftrl_model_unit::ftrl_model_unit(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
ftrl_model_unit(int factor_num, const vector<string>& modelLineSeg)
    {
        vi.resize(factor_num);
        v_ni.resize(factor_num);
        v_zi.resize(factor_num);
        wi = stod(modelLineSeg[1]);
        w_ni = stod(modelLineSeg[2 + factor_num]);
        w_zi = stod(modelLineSeg[3 + factor_num]);
        for(int f = 0; f < factor_num; ++f)
        {
            vi[f] = stod(modelLineSeg[2 + f]);
            v_ni[f] = stod(modelLineSeg[4 + factor_num + f]);
            v_zi[f] = stod(modelLineSeg[4 + 2 * factor_num + f]);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
leaq 0x18(%rdi), %rdi
leaq 0x30(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%r14), %rax
movq %rax, (%rsp)
movslq %esi, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movq %rdi, 0x10(%rsp)
movq %rbp, %rsi
callq 0x4a3c
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x4a3c
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x4a3c
movq (%r12), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4cbf
movsd %xmm0, (%r14)
movq (%r12), %rax
shlq $0x5, %rbp
leaq (%rax,%rbp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
callq 0x4cbf
movsd %xmm0, 0x8(%r14)
movq (%r12), %rax
leaq (%rax,%rbp), %rdi
addq $0x60, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x4cbf
movsd %xmm0, 0x10(%r14)
leal (,%r13,2), %eax
testl %r13d, %r13d
cmovlel %ebx, %r13d
movslq %eax, %r14
shlq $0x5, %r14
movl $0x80, %eax
addq %rax, %r14
addq %rax, %rbp
pushq $0x40
popq %r15
cmpq %rbx, %r13
je 0x47d4
movq (%r12), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x4cbf
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbx,8)
movq (%r12), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x4cbf
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbx,8)
movq (%r12), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x4cbf
movq (%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
addq $0x20, %r14
addq $0x20, %rbp
addq $0x20, %r15
jmp 0x476e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47e5
movq %rax, %r12
movq (%rsp), %rdi
callq 0x4c1c
movq 0x8(%rsp), %rdi
callq 0x4c1c
movq 0x10(%rsp), %rdi
callq 0x4c1c
movq %r12, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/src/Frame/pc_frame.cpp
// Function: pc_frame::init(pc_task&, int, int, int)
bool pc_frame::init(pc_task& task, int t_num, int buf_size, int log_num)
{
    pTask = &task;
    threadNum = t_num;
    bufSize = buf_size;
    logNum = log_num;
    sem_init(&semPro, 0, 1);
    sem_init(&semCon, 0, 0);
    threadVec.clear();
    threadVec.push_back(thread(&pc_frame::proThread, this));
    for(int i = 0; i < threadNum; ++i)
    {
        threadVec.push_back(thread(&pc_frame::conThread, this));
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movl %edx, (%rdi)
movl %ecx, 0xe0(%rdi)
movl %r8d, 0xe4(%rdi)
addq $0x38, %rdi
xorl %ebp, %ebp
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x3200
leaq 0x58(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3200
leaq 0xc8(%rbx), %r14
movq %r14, %rdi
callq 0x60e4
leaq 0xad(%rip), %rax        # 0x5d44
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x60ec
movq %r14, %rdi
movq %r15, %rsi
callq 0x69e8
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x521a
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpl (%rbx), %ebp
jge 0x5d1b
leaq 0x2b4(%rip), %rax       # 0x5f9a
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x60ec
movq %r14, %rdi
movq %r15, %rsi
callq 0x69e8
movq %r15, %rdi
callq 0x521a
incl %ebp
jmp 0x5cdb
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d2e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x521a
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rdi), %r13
leaq 0x38(%rdi), %rax
movq %rax, 0x18(%rsp)
pushq $0x60
popq %r15
movq %r14, %rdi
callq 0x64f2
movq 0x8(%rsp), %rdi
callq 0x3160
movq 0x10(%rsp), %rdi
callq 0x449c
xorl %ebp, %ebp
movl 0xe0(%rbx), %r12d
cmpl %r12d, %ebp
jge 0x6040
movq 0x88(%rbx), %rsi
cmpq %rsi, 0xa8(%rbx)
je 0x6040
movq %r14, %rdi
callq 0x64fa
movq 0x88(%rbx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r15
addl %eax, %ebp
movq %r13, %rdi
callq 0x75be
jmp 0x5ffd
movq 0x10(%rsp), %rdi
callq 0x31b0
movq 0x18(%rsp), %rdi
callq 0x33b0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
cmpl %r12d, %ebp
jge 0x5fdf
movq 0x8(%rsp), %rdi
callq 0x33b0
leaq 0x20(%rsp), %rdi
callq 0x6526
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x608e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6526
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/src/Utils/utils.cpp
// Function: utils::splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void utils::splitString(string& line, char delimiter, vector<string>* r)
{
    int begin = 0;
    for(int i = 0; i < line.size(); ++i)
    {
        if(line[i] == delimiter)
        {
            (*r).push_back(line.substr(begin, i - begin));
            begin = i + 1;
        }
    }
    if(begin < line.size())
        (*r).push_back(line.substr(begin, line.size() - begin));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
movq %rsp, %r15
xorl %eax, %eax
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movslq %eax, %rdx
cmpq %r12, %rcx
jbe 0x7688
cmpb %bpl, (%rsi,%r12)
je 0x765a
incq %r12
jmp 0x7647
movl %r12d, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a8e
movq %r15, %rdi
callq 0x3458
incq %r12
movl %r12d, %eax
jmp 0x7640
subq %rdx, %rcx
jbe 0x76ae
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a8e
movq %rsp, %rdi
callq 0x3458
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76bd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76e6
ucomisd 0xba5(%rip), %xmm0      # 0x82b0
jne 0x770f
jnp 0x76fe
movsd %xmm0, (%rsp)
callq 0x76e6
movsd (%rsp), %xmm4
movapd %xmm0, %xmm5
addsd 0xc86(%rip), %xmm5      # 0x83b0
mulsd 0xc86(%rip), %xmm5      # 0x83b8
movapd %xmm4, %xmm0
addsd 0xc82(%rip), %xmm0      # 0x83c0
movapd %xmm5, %xmm1
andpd 0xcb6(%rip), %xmm1      # 0x8400
addsd 0xc76(%rip), %xmm1      # 0x83c8
movapd %xmm0, %xmm2
mulsd 0xc72(%rip), %xmm2      # 0x83d0
movapd %xmm1, %xmm3
mulsd 0xc6e(%rip), %xmm3      # 0x83d8
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd 0xc5e(%rip), %xmm0      # 0x83e0
jb 0x77e6
ucomisd 0xc5c(%rip), %xmm0      # 0x83e8
ja 0x76fe
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
movapd %xmm0, 0x10(%rsp)
movapd %xmm4, %xmm0
mulsd 0xc44(%rip), %xmm0      # 0x83f0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm4, %xmm0
movapd %xmm5, 0x20(%rsp)
callq 0x31d0
movapd 0x20(%rsp), %xmm5
movsd (%rsp), %xmm4
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x76fe
divsd %xmm4, %xmm5
movapd %xmm5, %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq 0x8(%rsi), %r14
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movq %r14, %rsi
callq 0x20b0
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq 0x2e4(%rip), %rax       # 0x2804
movq %rax, 0x18(%rsi)
leaq 0x2e3(%rip), %rax       # 0x280e
movq %rax, 0x10(%rsi)
leaq -0x40(%rbp), %rdi
pushq $0x2
popq %rdx
callq 0x313c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x263e
leaq -0x40(%rbp), %rdi
callq 0x20e0
testq %rbx, %rbx
je 0x25e3
movq %rbx, %rdi
callq 0x3238
movq %rax, %r14
movq %rax, %rdi
callq 0x288e
leaq -0x80(%rbp), %r15
movq 0x9a61(%rip), %r12      # 0xbfd8
movq %r14, %rdi
callq 0x2dc8
testb %al, %al
je 0x25b3
movq %r15, %rdi
movq %r14, %rsi
callq 0x2dd2
movq %r12, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2bc0
jmp 0x2577
movq %r14, %rdi
addq $0x8, %rdi
callq 0x2726
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x322e
movq %rbx, %rdi
callq 0x265e
movq %rbx, %rdi
callq 0x21b0
xorl %eax, %eax
jmp 0x25f7
leaq 0x4a1a(%rip), %rdi      # 0x7004
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
pushq $-0x1
popq %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x263e
leaq -0x40(%rbp), %rdi
jmp 0x2622
movq %rax, %rbx
jmp 0x2627
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2860
movq (%rsi), %rdi
movq (%rdx), %rsi
movslq %eax, %rdx
callq 0x20d0
testl %eax, %eax
je 0x2864
shrl $0x1f, %eax
jmp 0x286a
xorl %eax, %eax
jmp 0x286a
cmpq %r14, %rbx
setb %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x70, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2ee6
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e7e
leaq -0x40(%rbp), %r15
leaq -0x48(%rbp), %r12
leaq -0x38(%rbp), %r13
movq -0x38(%rbp), %rax
cmpb $0x0, 0x79(%rax)
jne 0x290c
movq (%rbx), %rsi
movq 0x48(%rax), %rax
movq (%rax), %rdx
movq %r12, %rdi
callq 0x3274
movq %r13, %rdi
movq %r12, %rsi
callq 0x30d2
movq %r15, %rdi
callq 0x2688
movq %r14, %rdi
movq %r13, %rsi
callq 0x2e7e
jmp 0x28d0
movq 0x68(%rax), %rcx
cmpq 0x60(%rax), %rcx
je 0x2920
movb $0x1, 0x24(%rbx)
andl $0x0, 0x20(%rbx)
jmp 0x292c
movb $0x0, 0x24(%rbx)
movq %r14, %rdi
callq 0x2eba
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x4, %rsi
leaq 0x46ee(%rip), %rdi      # 0x702d
xorl %eax, %eax
callq 0x2040
leaq -0x30(%rbp), %rdi
callq 0x2688
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2962
jmp 0x2962
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2688
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x70, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2ee6
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e7e
leaq -0x40(%rbp), %r15
leaq -0x48(%rbp), %r12
leaq -0x38(%rbp), %r13
movq -0x38(%rbp), %rcx
cmpb $0x0, 0x79(%rcx)
jne 0x29f5
movq (%rbx), %rsi
movq 0x50(%rcx), %rax
movq -0x8(%rax), %rdx
movq %r12, %rdi
callq 0x3274
movq %r13, %rdi
movq %r12, %rsi
callq 0x30d2
movq %r15, %rdi
callq 0x2688
movq %r14, %rdi
movq %r13, %rsi
callq 0x2e7e
jmp 0x29b8
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
je 0x2a0e
shrq $0x6, %rax
movb $0x1, 0x24(%rbx)
decl %eax
movl %eax, 0x20(%rbx)
jmp 0x2a1a
movb $0x0, 0x24(%rbx)
movq %r14, %rdi
callq 0x2eba
leaq -0x30(%rbp), %rdi
callq 0x2688
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a36
jmp 0x2a36
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2688
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/rocket323[P]fishdb/./iter.cpp
// Function: fishdb::Iterator::Seek(char const*)
void Iterator::Seek(const char *k)
{
    std::string key = k;
    auto now = m_btree->m_root;

    bool found_upper = false;
    while (now != NULL)
    {
        m_stack.push_back(now);
        auto iter = m_btree->LowerBound(now, key);
        size_t p = iter - now->kvs.begin();
        if (iter != now->kvs.end())
        {
            found_upper = true;
            m_kv_idx = p;
            now = m_btree->ReadPage(now->children[p]);
        }
        else if (!now->is_leaf)
        {
            now = m_btree->ReadPage(now->children[p]);
        }
        else
        {
            break;
        }
    }

    m_valid = found_upper;
    if (!m_valid)
        m_stack.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %r15
movq %r15, %rdx
callq 0x20b0
movq (%rbx), %rsi
addq $0x70, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2ee6
leaq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x68(%rbp), %r14
leaq -0x58(%rbp), %r13
cmpq $0x0, -0x48(%rbp)
je 0x2b56
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x2e7e
movq (%rbx), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ee6
movq %r12, %rdi
movq %r14, %rsi
leaq -0x88(%rbp), %rdx
callq 0x3308
movq %rax, %r12
leaq -0x60(%rbp), %rdi
callq 0x2688
movq -0x48(%rbp), %rcx
movq %r12, %rax
subq 0x60(%rcx), %rax
sarq $0x6, %rax
cmpq 0x68(%rcx), %r12
jne 0x2b22
cmpb $0x0, 0x79(%rcx)
jne 0x2b56
movq (%rbx), %rsi
movq 0x48(%rcx), %rcx
movq (%rcx,%rax,8), %rdx
movq %r13, %rdi
callq 0x3274
movq %r15, %rdi
movq %r13, %rsi
callq 0x30d2
leaq -0x50(%rbp), %rdi
callq 0x2688
jmp 0x2a98
movl %eax, 0x20(%rbx)
movq (%rbx), %rsi
movq 0x48(%rcx), %rcx
movq (%rcx,%rax,8), %rdx
movq %r13, %rdi
callq 0x3274
movq %r15, %rdi
movq %r13, %rsi
callq 0x30d2
leaq -0x50(%rbp), %rdi
callq 0x2688
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x2a98
movl -0x2c(%rbp), %eax
movb %al, 0x24(%rbx)
testb $0x1, %al
jne 0x2b69
movq -0x38(%rbp), %rdi
callq 0x2eba
leaq -0x40(%rbp), %rdi
callq 0x2688
leaq -0x88(%rbp), %rdi
callq 0x20e0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b91
jmp 0x2b91
movq %rax, %rbx
jmp 0x2ba2
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2688
leaq -0x40(%rbp), %rdi
callq 0x2688
leaq -0x88(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44d8
movl %r14d, 0x48(%rbx)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57c0
movl %eax, %r14d
leaq -0x50(%rbp), %rdi
callq 0x20e0
testl %r14d, %r14d
je 0x31ce
xorl %ebx, %ebx
jmp 0x320a
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5a54
movq %rbx, %rdi
addq $0x70, %rdi
movq %r14, %rsi
callq 0x30d2
leaq -0x28(%rbp), %rdi
callq 0x2688
movq 0x70(%rbx), %rax
movq (%rax), %rsi
leaq 0x3ed5(%rip), %rdi      # 0x70d8
xorl %eax, %eax
callq 0x2040
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x60(%rax), %r12
addq $0x50, %r15
movq 0x68(%rax), %rax
cmpq %rax, %r12
je 0x334e
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4538
testb %al, %al
je 0x334b
addq $0x40, %r12
movq (%r14), %rax
jmp 0x3327
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x60(%rax), %r12
addq $0x50, %r15
movq 0x68(%rax), %rax
cmpq %rax, %r12
je 0x339e
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4538
testb %al, %al
jne 0x339b
addq $0x40, %r12
movq (%r14), %rax
jmp 0x3377
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x48(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
leaq 0x70(%rdi), %rsi
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x2ee6
leaq -0x68(%rbp), %r15
cmpq $0x0, -0x40(%rbp)
je 0x34cf
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %r13
movq %rbx, %rsi
callq 0x2ee6
movq %r12, %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq 0x3308
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2688
movq -0x40(%rbp), %rax
movq %rbx, %r14
subq 0x60(%rax), %r14
cmpq 0x68(%rax), %rbx
je 0x3496
movq %r12, %rdi
movq %rbx, %rsi
movq -0x30(%rbp), %rdx
callq 0x32c6
testb %al, %al
jne 0x34d9
movq -0x40(%rbp), %rax
cmpb $0x0, 0x79(%rax)
jne 0x34d3
movq 0x48(%rax), %rax
sarq $0x3, %r14
movq (%rax,%r14), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3274
movq %r13, %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x30d2
leaq -0x60(%rbp), %rdi
callq 0x2688
jmp 0x3436
pushq $-0x1
jmp 0x34d5
pushq $-0x2
popq %r14
jmp 0x34ec
addq $0x20, %rbx
xorl %r14d, %r14d
movq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x2110
leaq -0x38(%rbp), %rdi
callq 0x2688
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x350b
jmp 0x350b
movq %rax, %rbx
jmp 0x351c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2688
leaq -0x38(%rbp), %rdi
callq 0x2688
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30e0(%rip), %rsi      # 0x72e8
movq %r15, %rdi
callq 0x21d0
movq %rbx, -0x30(%rbp)
xorl %r12d, %r12d
leaq 0x2ecc(%rip), %r13      # 0x70ea
leaq 0x30c5(%rip), %rbx      # 0x72ea
xorl %r15d, %r15d
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rax
subq %rsi, %rax
sarq $0x6, %rax
cmpq %rax, %r15
jae 0x4275
addq %r12, %rsi
leaq -0x1a8(%rbp), %rdi
callq 0x21a0
movq 0x68(%r14), %rcx
subq 0x60(%r14), %rcx
sarq $0x6, %rcx
decq %rcx
cmpq %rcx, %r15
movq %rbx, %rsi
cmoveq %r13, %rsi
movq %rax, %rdi
callq 0x21d0
incq %r15
addq $0x40, %r12
jmp 0x4228
leaq 0x3070(%rip), %rsi      # 0x72ec
leaq -0x1a8(%rbp), %rdi
callq 0x21d0
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22e0
leaq -0x1a8(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42be
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fe2(%rip), %rsi      # 0x72e8
movq %r15, %rdi
callq 0x21d0
movq %rbx, -0x30(%rbp)
xorl %r12d, %r12d
leaq 0x2dce(%rip), %r13      # 0x70ea
leaq 0x2fc7(%rip), %rbx      # 0x72ea
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x4369
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x21c0
movq 0x50(%r14), %rcx
subq 0x48(%r14), %rcx
sarq $0x3, %rcx
decq %rcx
cmpq %rcx, %r12
movq %rbx, %rsi
cmoveq %r13, %rsi
movq %rax, %rdi
callq 0x21d0
incq %r12
jmp 0x4323
leaq 0x2f7c(%rip), %rsi      # 0x72ec
leaq -0x1a8(%rbp), %rdi
callq 0x21d0
movq -0x30(%rbp), %rbx
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x22e0
leaq -0x1a8(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43b2
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x41d8
movq (%r12), %r13
movq (%rbx), %rdx
leaq -0x78(%rbp), %rdi
callq 0x42d6
leaq -0x78(%rbp), %rax
movq (%rax), %rcx
leaq 0x2edd(%rip), %rdi      # 0x72ee
xorl %r12d, %r12d
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2040
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0x58(%rbp), %r13
movq %r13, %rdi
callq 0x20e0
leaq -0x38(%rbp), %r15
movq (%rbx), %rcx
movq 0x48(%rcx), %rax
movq 0x50(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x4498
movq (%rax,%r12,8), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x3274
movq (%rbx), %rax
movq 0x48(%rax), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3274
movq %r14, %rdi
movq %r15, %rsi
callq 0x43ca
leaq -0x30(%rbp), %rdi
callq 0x2688
leaq -0x50(%rbp), %rdi
callq 0x2688
incq %r12
jmp 0x443a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
jmp 0x44cf
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2688
jmp 0x44c6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2688
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x21f0
andq $0x0, 0x10(%rax)
pxor %xmm0, %xmm0
movdqa %xmm0, (%rax)
movq %rax, 0x30(%rbx)
movq (%r14), %rdi
leaq 0x1b70(%rip), %rsi      # 0x7360
callq 0x2240
movq %rax, 0x38(%rbx)
testq %rax, %rax
jne 0x581a
movq (%r14), %rdi
leaq 0x1b5c(%rip), %rsi      # 0x7364
callq 0x2240
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x58c5
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x58af
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
andq $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 0x2290
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
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
jmp 0x58be
movq 0x38(%rbx), %rcx
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a9c(%rip), %rdi      # 0x7368
leaq 0x1a9c(%rip), %rsi      # 0x736f
leaq 0x1aa1(%rip), %rcx      # 0x737b
pushq $0x10
popq %rdx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5930
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_O2/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 $0x48, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
movq %rdi, %rbx
leaq -0x50(%rbp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq 0x18(%rdi), %r13
leaq 0x8(%rdi), %r15
leaq -0x58(%rbp), %r14
cmpq %r15, %r13
je 0x59de
movl -0x30(%rbp), %eax
cmpl %eax, 0x28(%rbx)
jle 0x59de
leaq 0x28(%r13), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2ee6
movq -0x60(%rbp), %rax
movb 0x78(%rax), %al
xorb $0x1, %al
orb -0x2c(%rbp), %al
cmpb $0x1, %al
jne 0x59c9
movq %r14, %r12
leaq -0x70(%rbp), %r14
movq %r14, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2ee6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5eec
leaq 0x20(%r13), %r14
leaq -0x68(%rbp), %rdi
callq 0x2688
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r12, %r14
callq 0x4774
movq %r14, %rdi
callq 0x2688
movq %r13, %rdi
callq 0x2150
movq %rax, %r13
jmp 0x5965
xorl %r14d, %r14d
xorl %r15d, %r15d
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r15
jae 0x5a0c
addq %r14, %rsi
movq %rbx, %rdi
callq 0x6694
incq %r15
addq $0x8, %r14
jmp 0x59e4
leaq -0x50(%rbp), %rdi
callq 0x6680
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5a35
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2688
movq %r12, %rdi
callq 0x2688
jmp 0x5a42
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6680
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5aa9
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x5bfc
movq (%rbx), %rax
movq (%rax), %rax
movq 0x30(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x5ac9
leaq 0x190d(%rip), %rdi      # 0x73a0
leaq 0x18d5(%rip), %rsi      # 0x736f
leaq 0x192c(%rip), %rcx      # 0x73cd
pushq $0x3d
popq %rdx
callq 0x2140
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ad2
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_O2/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 %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq 0x30(%rsi), %rax
movq (%rax), %rdx
cmpq $-0x1, %rdx
je 0x5b2e
leaq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x5d7e
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x30d2
leaq -0x20(%rbp), %rdi
callq 0x2688
movq (%rbx), %rsi
movq 0x10(%rsi), %rax
movq 0x30(%r14), %rcx
movq %rax, (%rcx)
jmp 0x5b62
leaq -0x28(%rbp), %rdi
callq 0x62b9
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x30d2
leaq -0x20(%rbp), %rdi
callq 0x2688
movq 0x30(%r14), %rax
movq 0x10(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq (%rbx), %rsi
movq %rcx, (%rsi)
movb %r15b, 0x8(%rsi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rsi)
andl $0x0, 0x20(%rsi)
movw $0x1, 0x24(%rsi)
movb $0x1, 0x26(%rsi)
cmpl $0x2, %r15d
jne 0x5bb7
movq %r14, %rdi
callq 0x651a
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
jne 0x5bb7
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2ee6
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e9a
leaq -0x30(%rbp), %rdi
callq 0x2688
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2688
jmp 0x5bda
jmp 0x5bd7
jmp 0x5bd7
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2688
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/rocket323[P]fishdb/./pager.cpp
// Function: fishdb::Pager::GetPage(long, bool)
std::shared_ptr<MemPage> Pager::GetPage(int64_t page_no, bool stick)
{
    assert(page_no > 0);
    auto iter = m_pages.find(page_no);
    std::shared_ptr<MemPage> mp;
    if (iter != m_pages.end())
    {
        mp = iter->second;
    }
    else
    {
        // read page(s) from file
        mp = ReadPage(page_no);
        assert(mp != nil);
        int64_t of_page_no = mp->header.of_page_no;
        while (of_page_no > 0)
        {
            auto of_mp = ReadPage(of_page_no);
            mp->Feed(of_mp->data.c_str(), of_mp->data.size());
            of_page_no = of_mp->header.of_page_no;
        }
        if (mp->header.type == TREE_PAGE)
        {
            mp->Parse();
            CachePage(mp);
        }
    }
    mp->stick |= stick;
    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x48(%rbp)
testq %rdx, %rdx
jle 0x5d17
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x651a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x5c52
addq $0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4816
jmp 0x5cfc
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x5d7e
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x30d2
leaq -0x38(%rbp), %rdi
callq 0x2688
movq (%rbx), %rax
cmpq 0x657f(%rip), %rax      # 0xc200
je 0x5d30
movq 0x18(%rax), %r14
leaq -0x38(%rbp), %r12
leaq -0x40(%rbp), %r13
testq %r14, %r14
jle 0x5ccb
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5d7e
movq (%rbx), %rdi
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rsi
movl 0x30(%rax), %edx
callq 0x6a32
movq -0x40(%rbp), %rax
movq 0x18(%rax), %r14
movq %r12, %rdi
callq 0x2688
jmp 0x5c93
movq (%rbx), %rdi
cmpb $0x2, 0x8(%rdi)
jne 0x5cfc
callq 0x6b4c
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ee6
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e9a
leaq -0x50(%rbp), %rdi
callq 0x2688
movq (%rbx), %rax
movl -0x2c(%rbp), %ecx
orb %cl, 0x78(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16e1(%rip), %rdi      # 0x73ff
leaq 0x164a(%rip), %rsi      # 0x736f
leaq 0x16df(%rip), %rcx      # 0x740b
pushq $0x66
jmp 0x5d47
leaq 0x13b4(%rip), %rdi      # 0x70eb
leaq 0x1631(%rip), %rsi      # 0x736f
leaq 0x16c6(%rip), %rcx      # 0x740b
pushq $0x71
popq %rdx
callq 0x2140
movq %rax, %r14
leaq -0x50(%rbp), %rdi
jmp 0x5d60
jmp 0x5d67
jmp 0x5d67
movq %rax, %r14
movq %r12, %rdi
callq 0x2688
jmp 0x5d6a
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2688
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x418, %rsp            # imm = 0x418
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x5db4
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %r13
shlq $0x9, %r13
leaq 0x200(%r13), %rax
cmpq 0x40(%rsi), %rax
jle 0x5dc8
leaq 0x6445(%rip), %rsi      # 0xc200
movq %rbx, %rdi
callq 0x2ee6
jmp 0x5e71
leaq -0x38(%rbp), %rdi
callq 0x62b9
leaq -0x38(%rbp), %rax
movq (%rax), %r12
movq 0x38(%r15), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2220
movq 0x38(%r15), %rcx
pushq $0x28
popq %rsi
pushq $0x1
popq %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x22c0
movq 0x38(%r15), %rcx
leaq -0x440(%rbp), %r15
movl $0x1d8, %esi            # imm = 0x1D8
movq %r15, %rdi
movq %r13, %rdx
callq 0x22c0
leaq -0x38(%rbp), %rax
movq (%rax), %rdi
movq %r15, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x6a32
movq -0x38(%rbp), %rax
cmpq %r14, (%rax)
jne 0x5e4b
movq %rax, (%rbx)
movq -0x30(%rbp), %rax
andq $0x0, -0x30(%rbp)
movq %rax, 0x8(%rbx)
andq $0x0, -0x38(%rbp)
jmp 0x5e68
movq %rbx, %rdi
callq 0x62b9
movq (%rbx), %rax
movq %r14, (%rax)
movw $0x1, 0x24(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
leaq -0x30(%rbp), %rdi
callq 0x2688
movq %rbx, %rax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2688
movq %rbx, %rdi
callq 0x2310