LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::AeroForce(forrocket::Rocket*)
Eigen::Vector3d forrocket::DynamicsBase::AeroForce(Rocket* p_rocket) {
    Eigen::Vector3d force_aero;

    double force_axial = p_rocket->dynamic_pressure * p_rocket->CA * p_rocket->area;
    double force_normal = p_rocket->dynamic_pressure * p_rocket->CNa * p_rocket->area;
    double force_normal_y_axis = force_normal * p_rocket->sideslip_angle;
    double force_normal_z_axis = force_normal * p_rocket->angle_of_attack;
    force_aero << -force_axial, force_normal_y_axis, -force_normal_z_axis;

    return force_aero;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movsd 0x1f0(%rdx), %xmm0
movsd 0x350(%rdx), %xmm1
movsd 0x270(%rdx), %xmm3
mulsd %xmm1, %xmm3
xorpd 0x196d8(%rip), %xmm1    # 0x3a710
mulsd %xmm0, %xmm3
mulsd 0x268(%rdx), %xmm1
movsd 0x468(%rdx), %xmm2
movapd %xmm3, 0x30(%rsp)
mulsd %xmm3, %xmm2
leaq 0x48(%rsp), %rsi
movsd %xmm2, (%rsi)
movsd 0x460(%rdx), %xmm2
movsd %xmm2, 0x8(%rsp)
mulsd %xmm0, %xmm1
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd %xmm1, (%rbx)
callq 0x16d64
movapd 0x30(%rsp), %xmm0
xorpd 0x1966b(%rip), %xmm0    # 0x3a710
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
leaq 0x40(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x21103
cmpq $0x1, 0x20(%rsp)
jne 0x21103
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x210e3
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x21103
cmpq $0x1, 0x20(%rsp)
jne 0x21103
movq %rax, %rdi
callq 0x55e0
leaq 0x1963e(%rip), %rdi     # 0x3a748
leaq 0x196d5(%rip), %rsi     # 0x3a7e6
leaq 0x198c0(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::GyroEffectMoment(forrocket::Rocket*)
Eigen::Vector3d forrocket::DynamicsBase::GyroEffectMoment(Rocket* p_rocket) {
    Eigen::Vector3d gyro_effect;

    Eigen::Vector3d angular_momentum = p_rocket->getInertiaTensor() * p_rocket->angular_velocity;
    gyro_effect = p_rocket->angular_velocity.cross(angular_momentum);

    return -1.0 * gyro_effect;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x20a96
leaq 0x430(%r14), %rax
movupd 0x430(%r14), %xmm0
movupd 0x438(%r14), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%r15), %xmm0
movupd 0x18(%r15), %xmm1
movapd %xmm3, %xmm2
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
mulpd 0x30(%r15), %xmm3
addpd %xmm2, %xmm3
movapd %xmm3, (%rsp)
leaq 0x20(%rsp), %rcx
leaq 0x98(%rsp), %rsi
movq %rcx, (%rsi)
movq %r15, 0x10(%rsi)
movq $0x2, 0x18(%rsi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rsi)
movq $0x1, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq %rax, 0x40(%rsi)
movq %rcx, 0x48(%rsi)
movq $0x3, 0x58(%rsi)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x1a0a4
movq 0x10(%r15), %rax
movq 0x20(%r15), %rcx
movupd (%rcx), %xmm0
movsd (%rax), %xmm1
movhpd 0x18(%rax), %xmm1       # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
movsd 0x30(%rax), %xmm2
mulsd 0x10(%rcx), %xmm2
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movapd (%rsp), %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1            # xmm1 = xmm1[1],xmm5[1]
movsd 0x430(%r14), %xmm2
movupd 0x438(%r14), %xmm3
movapd %xmm5, %xmm4
shufpd $0x1, %xmm0, %xmm4      # xmm4 = xmm4[1],xmm0[0]
unpcklpd %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0]
mulpd %xmm3, %xmm0
mulsd %xmm3, %xmm5
shufpd $0x1, %xmm2, %xmm3      # xmm3 = xmm3[1],xmm2[0]
mulpd %xmm3, %xmm4
subpd %xmm4, %xmm0
mulsd %xmm2, %xmm1
subsd %xmm5, %xmm1
movapd 0x194b2(%rip), %xmm2    # 0x3a710
xorpd %xmm2, %xmm0
movupd %xmm0, (%rbx)
xorpd %xmm2, %xmm1
movlpd %xmm1, 0x10(%rbx)
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::ThrustMoment(forrocket::Rocket*)
Eigen::Vector3d forrocket::DynamicsBase::ThrustMoment(Rocket* p_rocket) {
    Eigen::Vector3d moment_thrust;

    Eigen::Vector3d moment_arm(p_rocket->length_CG - p_rocket->length_thrust, 0.0, 0.0);
    moment_thrust = p_rocket->force.thrust.cross(moment_arm);
    
    return moment_thrust;
}

// Assembly:
movq %rdi, %rax
movsd 0x200(%rdx), %xmm0
movsd 0x388(%rdx), %xmm1
subsd 0x1e0(%rdx), %xmm0
movupd 0x390(%rdx), %xmm2
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
mulpd %xmm2, %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd 0x19450(%rip), %xmm4    # 0x3a710
mulsd %xmm2, %xmm0
addpd %xmm4, %xmm3
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm0, %xmm2
movupd %xmm3, (%rdi)
movsd %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::AeroForceMoment(forrocket::Rocket*)
Eigen::Vector3d forrocket::DynamicsBase::AeroForceMoment(Rocket* p_rocket) {
    Eigen::Vector3d moment_aero;

    Eigen::Vector3d moment_arm(p_rocket->length_CG - p_rocket->length_CP, 0.0, 0.0);
    moment_aero = p_rocket->force.aero.cross(moment_arm);
    moment_aero[0] = p_rocket->dynamic_pressure * p_rocket->Cld * p_rocket->area * p_rocket->length * p_rocket->cant_angle_fin * 4;

    return moment_aero;
}

// Assembly:
movq %rdi, %rax
movsd 0x200(%rdx), %xmm0
movsd 0x3a0(%rdx), %xmm1
subsd 0x208(%rdx), %xmm0
movupd 0x3a8(%rdx), %xmm2
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
mulpd %xmm2, %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd 0x193f2(%rip), %xmm4    # 0x3a710
mulsd %xmm2, %xmm0
addpd %xmm4, %xmm3
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm0, %xmm2
movupd %xmm3, (%rdi)
movsd %xmm2, 0x10(%rdi)
movsd 0x350(%rdx), %xmm0
mulsd 0x278(%rdx), %xmm0
mulsd 0x1f0(%rdx), %xmm0
mulsd 0x1f8(%rdx), %xmm0
mulsd 0x298(%rdx), %xmm0
mulsd 0x193c5(%rip), %xmm0    # 0x3a730
movsd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::AeroDampingMoment(forrocket::Rocket*)
Eigen::Vector3d forrocket::DynamicsBase::AeroDampingMoment(Rocket* p_rocket) {
    Eigen::Vector3d moment_aero_dumping;

    Eigen::Vector3d coefficient_aero_dumping(p_rocket->Clp, p_rocket->Cmq, p_rocket->Cnr);
    
    moment_aero_dumping = p_rocket->dynamic_pressure * coefficient_aero_dumping.array() * p_rocket->area * std::pow(p_rocket->length, 2)
                            / (2.0 * p_rocket->velocity.air_body.norm()) * p_rocket->angular_velocity.array();
    
    return moment_aero_dumping;
}

// Assembly:
movq %rdi, %rax
movsd 0x350(%rdx), %xmm1
movupd 0x1f0(%rdx), %xmm0
movupd 0x280(%rdx), %xmm3
movupd 0x330(%rdx), %xmm2
mulpd %xmm2, %xmm2
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4            # xmm4 = xmm4[1],xmm2[1]
addsd %xmm2, %xmm4
movsd 0x340(%rdx), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm4, %xmm2
sqrtsd %xmm2, %xmm2
addsd %xmm2, %xmm2
movapd %xmm1, %xmm4
unpcklpd %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0]
mulsd 0x290(%rdx), %xmm1
mulpd %xmm3, %xmm4
shufpd $0x2, %xmm0, %xmm1      # xmm1 = xmm1[0],xmm0[1]
mulpd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm4, %xmm0
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
mulpd %xmm3, %xmm0
mulsd %xmm1, %xmm3
divsd %xmm2, %xmm3
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movupd 0x430(%rdx), %xmm1
divpd %xmm2, %xmm0
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
mulsd 0x440(%rdx), %xmm3
movsd %xmm3, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_base.cpp
// Function: forrocket::DynamicsBase::QuaternionDiff(forrocket::Rocket*)
Eigen::Matrix4d forrocket::DynamicsBase::QuaternionDiff(Rocket* p_rocket) {
    double p = p_rocket->angular_velocity[0];
    double q = p_rocket->angular_velocity[1];
    double r = p_rocket->angular_velocity[2];
    Eigen::Matrix4d quat_dot;
    quat_dot << 0, r, -q, p,
                -r, 0, p, q,
                q, -p, 0, r,
                -p, -q, -r, 0;
    return quat_dot;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movsd 0x430(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x438(%rdx), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd 0x440(%rdx), %xmm0
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
movq %rbx, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl $0x1, %ecx
movq %rcx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, (%rbx)
callq 0x216ce
movaps 0x40(%rsp), %xmm0
xorps 0x191e2(%rip), %xmm0    # 0x3a710
leaq 0x98(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x216ce
movsd 0x10(%rsp), %xmm0
xorps 0x191b5(%rip), %xmm0    # 0x3a710
leaq 0x90(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x88(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x216ce
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x216ce
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x216ce
movsd 0x8(%rsp), %xmm0
xorps 0x19157(%rip), %xmm0    # 0x3a710
leaq 0x80(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x78(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x216ce
movsd 0x8(%rsp), %xmm0
xorps 0x19116(%rip), %xmm0    # 0x3a710
leaq 0x70(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
movsd 0x18(%rsp), %xmm0
xorps 0x190f9(%rip), %xmm0    # 0x3a710
leaq 0x68(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
movsd 0x10(%rsp), %xmm0
xorps 0x190dc(%rip), %xmm0    # 0x3a710
leaq 0x60(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x216ce
leaq 0x58(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x216ce
movq 0x38(%rsp), %rax
addq 0x28(%rsp), %rax
cmpq $0x4, %rax
jne 0x216ae
cmpq $0x4, 0x30(%rsp)
jne 0x216ae
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
retq
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
jmp 0x2168e
movq 0x38(%rsp), %rcx
addq 0x28(%rsp), %rcx
cmpq $0x4, %rcx
jne 0x216ae
cmpq $0x4, 0x30(%rsp)
jne 0x216ae
movq %rax, %rdi
callq 0x55e0
leaq 0x19093(%rip), %rdi     # 0x3a748
leaq 0x1912a(%rip), %rsi     # 0x3a7e6
leaq 0x1a77b(%rip), %rcx     # 0x3be3e
movl $0x78, %edx
callq 0x5230
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/dynamics/dynamics_3dof_onlauncher.cpp
// Function: forrocket::Dynamics3dofOnLauncher::AeroForce(forrocket::Rocket*)
Eigen::Vector3d forrocket::Dynamics3dofOnLauncher::AeroForce(Rocket* p_rocket) {
    Eigen::Vector3d force_aero;

    double force_axial = p_rocket->dynamic_pressure * p_rocket->CA * p_rocket->area;
    double force_normal_y_axis = 0.0;
    double force_normal_z_axis = 0.0;
    force_aero << -force_axial, force_normal_y_axis, force_normal_z_axis;

    return force_aero;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movsd 0x350(%rdx), %xmm0
xorpd 0x18f5f(%rip), %xmm0    # 0x3a710
mulsd 0x268(%rdx), %xmm0
mulsd 0x1f0(%rdx), %xmm0
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd %xmm0, (%rbx)
callq 0x16d64
movq %rsp, %rsi
movq %rax, %rdi
callq 0x16d64
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
cmpq $0x3, %rax
jne 0x21820
cmpq $0x1, 0x18(%rsp)
jne 0x21820
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x18f21(%rip), %rdi     # 0x3a748
leaq 0x18fb8(%rip), %rsi     # 0x3a7e6
leaq 0x191a3(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
movq 0x20(%rsp), %rcx
addq 0x10(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x2185f
cmpq $0x1, 0x18(%rsp)
jne 0x2185f
movq %rax, %rdi
callq 0x55e0
callq 0x5b09
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/math/special_functions/lanczos.hpp
// Function: boost::math::lanczos::lanczos_initializer<boost::math::lanczos::lanczos17m64, long double>::init::init()
init()
      {
         T t(1);
         Lanczos::lanczos_sum(t);
         Lanczos::lanczos_sum_expG_scaled(t);
         Lanczos::lanczos_sum_near_1(t);
         Lanczos::lanczos_sum_near_2(t);
         Lanczos::g();
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
fld1
fstpt (%rsp)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x22946
fstp %st(0)
movq %rbx, %rdi
callq 0x22974
fstp %st(0)
movq %rbx, %rdi
callq 0x229a2
fstp %st(0)
movq %rbx, %rdi
callq 0x22a04
fstp %st(0)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/math/special_functions/lanczos.hpp
// Function: long double boost::math::lanczos::lanczos17m64::lanczos_sum_near_1<long double>(long double const&)
static T lanczos_sum_near_1(const T& dz)
   {
      lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
      static const T d[16] = {
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.493645054286536365763334986866616581265)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -16.95716370392468543800733966378143997694)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 26.19196892983737527836811770970479846644)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -21.3659076437988814488356323758179283908)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.913992596774556590710751047594507535764)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.62888300018780199210536267080940382158)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.3807056693542503606384861890663080735588)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.02714647489697685807340312061034730486958)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.0007815484715461206757220527133967191796747)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.6108630817371501052576880554048972272435e-5)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.5037380238864836824167713635482801545086e-8)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1483232144262638814568926925964858237006e-13)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.1346609158752142460943888149156716841693e-14)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.660492688923978805315914918995410340796e-15)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.1472114697343266749193617793755763792681e-15)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1410901942033374651613542904678399264447e-16)),
      };
      T result = 0;
      for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
      {
         result += (-d[k-1]*dz)/(k*dz + k*k);
      }
      return result;
   }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0x26d60(%rip), %al      # 0x49710
testb %al, %al
je 0x229fc
fldt (%rbx)
fldz
movl $0x1, %eax
leaq 0x26c4c(%rip), %rcx     # 0x49610
fldt (%rcx)
movl %eax, 0x8(%rsp)
movl %eax, %edx
imull %eax, %edx
movl %edx, 0xc(%rsp)
fld %st(2)
fimull 0x8(%rsp)
fxch %st(1)
fmul %st(3), %st
fxch %st(1)
fiaddl 0xc(%rsp)
fdivrp %st, %st(1)
fsubrp %st, %st(1)
incq %rax
addq $0x10, %rcx
cmpq $0x11, %rax
jne 0x229c4
fstp %st(1)
addq $0x10, %rsp
popq %rbx
retq
callq 0x5d07
jmp 0x229b4
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/math/special_functions/lanczos.hpp
// Function: long double boost::math::lanczos::lanczos17m64::lanczos_sum_near_2<long double>(long double const&)
static T lanczos_sum_near_2(const T& dz)
   {
      lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
      static const T d[16] = {
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 23.56409085052261327114594781581930373708)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -88.92116338946308797946237246006238652361)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 137.3472822086847596961177383569603988797)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -112.0400438263562152489272966461114852861)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 51.98768915202973863076166956576777843805)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -13.78552090862799358221343319574970124948)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.996371068830872830250406773917646121742)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1423525874909934506274738563671862576161)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.004098338646046865122459664947239111298524)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.3203286637326511000882086573060433529094e-4)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.2641536751640138646146395939004587594407e-7)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.7777876663062235617693516558976641009819e-13)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.7061443477097101636871806229515157914789e-14)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.3463537849537988455590834887691613484813e-14)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.7719578215795234036320348283011129450595e-15)),
         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.7398586479708476329563577384044188912075e-16)),
      };
      T result = 0;
      T z = dz + 2;
      for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
      {
         result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
      }
      return result;
   }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0x26e0e(%rip), %al      # 0x49820
testb %al, %al
je 0x22a6e
fldt (%rbx)
fld %st(0)
fadds 0x19968(%rip)           # 0x3c388
fldz
movl $0x1, %eax
leaq 0x26cf2(%rip), %rcx     # 0x49720
fld1
fchs
fldt (%rcx)
fmul %st(4), %st
movl %eax, 0x8(%rsp)
fld %st(3)
fimull 0x8(%rsp)
fadd %st(4), %st
movl %eax, %edx
imull %eax, %edx
movl %edx, 0xc(%rsp)
fiaddl 0xc(%rsp)
fadd %st(2), %st
fdivrp %st, %st(1)
fsubrp %st, %st(2)
incq %rax
addq $0x10, %rcx
cmpq $0x11, %rax
jne 0x22a32
fstp %st(3)
fstp %st(1)
fstp %st(1)
addq $0x10, %rsp
popq %rbx
retq
callq 0x5deb
jmp 0x22a16
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/solver/rocket_stage.cpp
// Function: forrocket::RocketStage::SwitchDynamics(double, forrocket::DynamicsBase**, forrocket::SequenceClock*, forrocket::EnvironmentWind*)
void forrocket::RocketStage::SwitchDynamics(const double time_start, DynamicsBase** dynamics,
                                            SequenceClock* master_clock, EnvironmentWind* wind) {
    // delete *dynamics;
    if (enable_program_attitude) {
        if (time_start >= time_start_attitude_controll && time_start < time_end_attitude_controll) {
            *dynamics = new Dynamics6dofProgramRate(&rocket, master_clock, wind);
            return;
        }
    }
    *dynamics = new Dynamics6dofAero(&rocket, master_clock, wind);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r13
movb 0x1180(%rdi), %bpl
movsd 0x1188(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1190(%rdi), %xmm0
movsd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x5340
movsd 0x10(%rsp), %xmm0
movq %rax, %rbx
addq $0x10, %r13
cmpb $0x1, %bpl
jne 0x2e44b
ucomisd 0x8(%rsp), %xmm0
jb 0x2e44b
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2e44b
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2526c
jmp 0x2e45c
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x23d84
movq %rbx, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e470
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/numeric/odeint/integrate/max_step_checker.hpp
// Function: boost::numeric::odeint::failed_step_checker::operator()()
void operator()(void)
    {
        if( m_steps++ >= m_max_steps )
        {
            char error_msg[200];
            std::sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
            BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) );
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl %edx, %eax
jge 0x30168
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd289(%rip), %rsi      # 0x3d3f8
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50c0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rbx, %rdi
callq 0x5190
leaq (%rsp,%rax), %rdx
addq $0x30, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9382
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5400
leaq 0x18957(%rip), %rax     # 0x48b10
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xd279(%rip), %rsi      # 0x3d43f
leaq 0xd2b1(%rip), %rdx      # 0x3d47e
movl $0x69, %ecx
callq 0x30b68
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5390
jmp 0x301e7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x301fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5350
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
// Function: boost::numeric::odeint::controlled_step_result boost::numeric::odeint::controlled_runge_kutta<boost::numeric::odeint::runge_kutta_dopri5<std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>, boost::numeric::odeint::default_error_checker<double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>, boost::numeric::odeint::default_step_adjuster<double, double>, boost::numeric::odeint::initially_resizer, boost::numeric::odeint::explicit_error_stepper_fsal_tag>::try_step<std::reference_wrapper<forrocket::DynamicsBase>, std::array<double, 14ul>, std::array<double, 14ul>>(std::reference_wrapper<forrocket::DynamicsBase>, std::array<double, 14ul>&, std::array<double, 14ul>&, double&, double&)
controlled_step_result try_step( System system , StateInOut &x , DerivInOut &dxdt , time_type &t , time_type &dt )
    {
        m_xnew_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_xnew_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
        m_dxdt_new_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_new_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
        controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , m_dxdtnew.m_v , dt );
        if( res == success )
        {
            boost::numeric::odeint::copy( m_xnew.m_v , x );
            boost::numeric::odeint::copy( m_dxdtnew.m_v , dxdt );
        }
        return res;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rax
movq %rcx, %rbx
movq %rdx, %r14
cmpb $0x0, 0x3ba(%rdi)
jne 0x3029f
movb $0x1, 0x3ba(%rdi)
cmpb $0x0, 0x3bb(%rdi)
jne 0x302af
movb $0x1, 0x3bb(%rdi)
leaq 0x4a0(%rdi), %r12
leaq 0x510(%rdi), %r15
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r9
pushq %rax
pushq %r15
callq 0x30304
addq $0x10, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x302f8
movl $0x70, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5550
movl $0x70, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5550
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/./lib/boost/numeric/odeint/util/resizer.hpp
// Function: void boost::numeric::odeint::explicit_generic_rk<4ul, 4ul, std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>::do_step_impl<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>>(forrocket::Dynamics3dofParachute, std::array<double, 14ul> const&, std::array<double, 14ul> const&, double, std::array<double, 14ul>&, double)
bool adjust_size( const State &x , ResizeFunction f )
    {
        if( !m_initialized )
        {
            m_initialized = true;
            return f( x );
        } else
            return false;
    }

// Assembly:
cmpb $0x0, 0xe8(%rdi)
jne 0x3151e
movb $0x1, 0xe8(%rdi)
subq $0x78, %rsp
leaq 0x78(%rdi), %rax
leaq 0x17423(%rip), %r9      # 0x48950
addq $0x10, %r9
leaq 0x10(%rsp), %r10
movq %r9, (%r10)
movups 0x8(%rsi), %xmm2
movups %xmm2, 0x8(%r10)
movq 0x18(%rsi), %rsi
movq %rsi, 0x18(%r10)
leaq 0xf0(%rdi), %r9
leaq 0x30(%rsp), %rsi
movq %rdi, (%rsi)
addq $0x160, %rdi            # imm = 0x160
movq %r10, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
movq %r9, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %rcx, 0x28(%rsi)
movq %rdi, 0x30(%rsi)
movsd %xmm0, 0x38(%rsi)
movsd %xmm1, 0x40(%rsi)
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x31594
addq $0x78, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Create_DB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int)
int Create_DB(string filename, int db_size, int segment_K, int shards_num, int ds_type) {
    cout << "Start CreateDB, Please wait ..." << endl;
    int ht_size = db_size ;
    int segment_size = SEG_UNIT_SIZE * segment_K;

    Options opts;
    opts.hashtable_size = ht_size;
    opts.segment_size = segment_size;
    opts.shards_num = shards_num;
    opts.datastor_type = ds_type;

    KVTime tv_start;
    KVDS *db = KVDS::Create_KVDS(filename.c_str(), opts);

    KVTime tv_end;
    double diff_time = (tv_end - tv_start) / 1000000.0;

    cout << "Create DB use time: " << diff_time << "s" << endl;
    if (!db) {
        return -1;
    }
    delete db;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x2d469(%rip), %r13     # 0x36fd0
leaq 0x1a5ab(%rip), %rsi     # 0x24119
movl $0x1f, %edx
movq %r13, %rdi
callq 0x6490
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %r13, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
shll $0xa, %r15d
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x19868
movl %r12d, 0x40(%r13)
movl %r15d, 0x44(%r13)
movl %r14d, 0x18(%r13)
movl %ebp, 0x3c(%r13)
leaq 0x68(%rsp), %rdi
callq 0x22e38
movq (%rbx), %rax
movl $0xa, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x15c3c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22e38
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x22ea4
movq %rax, %r14
movq 0x2d3c3(%rip), %rdi     # 0x36fd0
leaq 0x1a525(%rip), %rsi     # 0x24139
movl $0x14, %edx
callq 0x6490
cvtsi2sd %r14, %xmm0
divsd 0x1a3dd(%rip), %xmm0    # 0x24008
movq 0x2d39e(%rip), %rdi     # 0x36fd0
callq 0x6670
movq %rax, %r14
leaq 0x1a76f(%rip), %rsi     # 0x243b0
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %r14, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
testq %rbx, %rbx
je 0x9c87
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x9c8c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x58(%rsp), %rdi
callq 0x22ebe
leaq 0x68(%rsp), %rdi
callq 0x22ebe
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9cb6
movq %rax, %rbx
jmp 0x9cc8
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22ebe
leaq 0x68(%rsp), %rdi
callq 0x22ebe
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Open_DB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
KVDS* Open_DB(string filename, int shards_num, int aggregate = 0) {
    cout << "Start OpenDB, Please wait ..." << endl;
    Options opts;
    opts.shards_num = shards_num;
    opts.aggregate_request = aggregate;
    KVTime tv_start;
    KVDS *db = KVDS::Open_KVDS(filename.c_str(), opts);
    KVTime tv_end;
    double diff_time = (tv_end - tv_start) / 1000000.0;
    cout << "Open DB use time: " << diff_time << "s" << endl;
    return db;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x2d2da(%rip), %r15     # 0x36fd0
leaq 0x1a451(%rip), %rsi     # 0x2414e
movl $0x1d, %edx
movq %r15, %rdi
callq 0x6490
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %r15, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x19868
movl %r14d, 0x18(%r15)
testl %ebp, %ebp
setne 0x38(%r15)
leaq 0x68(%rsp), %rdi
callq 0x22e38
movq (%rbx), %rax
movl $0xa, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x15f8a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22e38
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x22ea4
movq %rax, %r14
movq 0x2d23e(%rip), %rdi     # 0x36fd0
leaq 0x1a3d3(%rip), %rsi     # 0x2416c
movl $0x12, %edx
callq 0x6490
cvtsi2sd %r14, %xmm0
divsd 0x1a258(%rip), %xmm0    # 0x24008
movq 0x2d219(%rip), %rdi     # 0x36fd0
callq 0x6670
movq %rax, %r14
leaq 0x1a5ea(%rip), %rsi     # 0x243b0
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %r14, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
leaq 0x58(%rsp), %rdi
callq 0x22ebe
leaq 0x68(%rsp), %rdi
callq 0x22ebe
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e21
movq %rax, %rbx
jmp 0x9e33
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22ebe
leaq 0x68(%rsp), %rdi
callq 0x22ebe
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Create_Keys(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>>>>&)
void Create_Keys(int record_num, vector<string> &key_list) {
    for (int index = 0; index < record_num; index++) {
        char c_key[KEY_SIZE+1] = "kkkkkkkkkk";
        stringstream key_ss;
        key_ss << index;
        string key(key_ss.str());
        memcpy(c_key, key.c_str(), key.length());
        string key_last = c_key;
        key_list.push_back(key_last);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
testl %edi, %edi
jle 0x9f3b
movq %rsi, %r14
movl %edi, %ebp
xorl %r13d, %r13d
leaq 0x50(%rsp), %rbx
movq %rsp, %r12
leaq 0x10(%rsp), %r15
movabsq $0x6b6b6b6b6b6b6b6b, %rax # imm = 0x6B6B6B6B6B6B6B6B
movq %rax, (%rsp)
movl $0x6b6b6b, 0x7(%rsp)    # imm = 0x6B6B6B
movq %rbx, %rdi
callq 0x6310
leaq 0x60(%rsp), %rdi
movl %r13d, %esi
callq 0x6700
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6650
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0x63c0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x61b0
leaq (%rsp,%rax), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xcb9e
movq %r14, %rdi
movq %r15, %rsi
callq 0xc4ac
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9eff
callq 0x6430
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x9f13
callq 0x6430
movq %rbx, %rdi
movq 0x2d08b(%rip), %rsi     # 0x36fa8
callq 0x6360
leaq 0xd0(%rsp), %rdi
callq 0x6130
incl %r13d
cmpl %r13d, %ebp
jne 0x9e73
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f4f
movq %rax, %rbx
jmp 0x9f84
movq %rax, %rbx
jmp 0x9f70
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9f70
callq 0x6430
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x9f84
callq 0x6430
movq 0x2d01d(%rip), %rsi     # 0x36fa8
leaq 0x50(%rsp), %rdi
callq 0x6360
leaq 0xd0(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: fun_insert(void*)
void* fun_insert(void *arg) {
    thread_arg *t_args = (thread_arg*) arg;
    KVDS *db = t_args->db;
    int key_start = t_args->key_start;
    int key_end = t_args->key_end;
    vector<string> &key_list = *t_args->key_list;
    uint64_t *latency = t_args->latency;

    string *value = t_args->data;

    int value_size = VALUE_SIZE;
    int key_len = KEY_SIZE;
    Status s;

    for (int i = key_start; i < key_end + 1; i++) {
        string key = key_list[i];
        //string key = key_list[i-key_start];
        KVTime tv_start;
        s = db->Insert(key.c_str(), key_len, value->c_str(), value_size);
        KVTime tv_end;
        latency[i - key_start] = (uint64_t)(tv_end - tv_start);
        if (!s.ok()) {
            cout << "Insert key=" << key << "to DB failed!" << endl;
        }
    }
    return NULL;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movslq 0x8(%rdi), %rax
movl 0xc(%rdi), %r13d
cmpl %r13d, %eax
jg 0xa127
movq (%rdi), %rcx
movq %rcx, 0x38(%rsp)
movq 0x10(%rdi), %rcx
movq %rcx, 0x40(%rsp)
movq 0x20(%rdi), %rcx
movq %rcx, 0x28(%rsp)
movq 0x18(%rdi), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, %rbx
shlq $0x5, %rbx
subl %eax, %r13d
incl %r13d
xorl %r14d, %r14d
leaq 0x58(%rsp), %r15
leaq 0x48(%rsp), %r12
movq 0x40(%rsp), %rax
movq (%rax), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xcb08
movq %r15, %rdi
callq 0x22e38
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rax
movq (%rax), %r8
movl $0x0, (%rsp)
movq %r12, %rdi
movq 0x38(%rsp), %rsi
movl $0xa, %ecx
movl $0x1000, %r9d           # imm = 0x1000
callq 0x16442
movl 0x48(%rsp), %ebp
movq %r12, %rdi
callq 0x22e38
movq %r12, %rdi
movq %r15, %rsi
callq 0x22ea4
movq 0x28(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
testl %ebp, %ebp
je 0xa0f3
movl $0xb, %edx
movq 0x2cf3e(%rip), %rdi     # 0x36fd0
leaq 0x1a0f1(%rip), %rsi     # 0x2418a
callq 0x6490
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x2cf21(%rip), %rdi     # 0x36fd0
callq 0x6490
movq %rax, %rbp
movl $0xd, %edx
movq %rax, %rdi
leaq 0x1a0d0(%rip), %rsi     # 0x24196
callq 0x6490
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %rbp, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
movq %r12, %rdi
callq 0x22ebe
movq %r15, %rdi
callq 0x22ebe
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa117
callq 0x6430
incq %r14
addq $0x20, %rbx
cmpl %r14d, %r13d
jne 0xa006
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xa15b
jmp 0xa13f
movq %rax, %rbx
jmp 0xa151
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x22ebe
leaq 0x58(%rsp), %rdi
callq 0x22ebe
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa16f
callq 0x6430
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Create_DB(benchmark_arg)
void Bench_Create_DB(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int db_size = bm_arg.db_size;
    int segment_K = bm_arg.segment_K;
    int shards_num = bm_arg.shards_num;
    int ds_type = bm_arg.ds_type;

    vector<string> key_list;
    if (Create_DB(file_path, db_size, segment_K, shards_num, ds_type) < 0) {
        cout << "Create DB Fail!!!" <<endl;
        return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0xcb08
movl 0x20(%r15), %ebx
movl 0x2c(%r15), %ebp
movl 0x30(%r15), %r14d
movl 0x34(%r15), %r15d
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0xcb08
leaq 0x38(%rsp), %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x9b40
movl %eax, %ebx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xb810
callq 0x6430
testl %ebx, %ebx
jns 0xb85a
movq 0x2b7b5(%rip), %rbx     # 0x36fd0
leaq 0x18c06(%rip), %rsi     # 0x24428
movl $0x11, %edx
movq %rbx, %rdi
callq 0x6490
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq 0x2b783(%rip), %rdi     # 0x36fd0
callq 0x6050
movq %rax, %rdi
callq 0x62f0
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb877
callq 0x6430
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xb89d
callq 0x6430
jmp 0xb89d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb8ba
callq 0x6430
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Write(benchmark_arg)
void Bench_Write(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;
    int aggregate = bm_arg.aggregate;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num, aggregate);

    Bench_Insert(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xcb08
movl 0x24(%r15), %ebp
movl 0x28(%r15), %ebx
movl 0x30(%r15), %r14d
movl 0x38(%r15), %r15d
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl %ebp, %edi
callq 0x9e45
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0xcb08
leaq 0x38(%rsp), %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x9cda
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xb95a
callq 0x6430
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0xa177
testq %r14, %r14
je 0xb97c
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb994
callq 0x6430
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xb9bc
callq 0x6430
jmp 0xb9bc
jmp 0xb9b9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb9d4
callq 0x6430
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Read(benchmark_arg)
void Bench_Read(benchmark_arg bm_arg)
{
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num);
    db->ClearReadCache();
    Bench_Get_Seq(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xcb08
movl 0x24(%r14), %ebp
movl 0x28(%r14), %ebx
movl 0x30(%r14), %r14d
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl %ebp, %edi
callq 0x9e45
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0xcb08
leaq 0x40(%rsp), %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x9cda
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xc21a
callq 0x6430
movq %r14, %rdi
callq 0x16944
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %ecx
callq 0xab74
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc254
callq 0x6430
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xc27a
callq 0x6430
jmp 0xc27a
jmp 0xc277
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc62e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc292
callq 0x6430
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: main
int main(int argc, char** argv) {

    benchmark_arg bm_arg;

    if(Parse_Option(argc, argv, bm_arg) < 0) {
        usage();
        return -1;
    }

    switch(bm_arg.bench_type) {
        case CREATE:
            Bench_Create_DB(bm_arg);
            break;
        case WRITE:
            Bench_Write(bm_arg);
            break;
        case OVERWRITE:
            Bench_Overwrite(bm_arg);
            break;
        case READ:
            Bench_Read(bm_arg);
            break;
        default:
            break;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rsp, %rdx
callq 0xb22f
testl %eax, %eax
js 0xc338
movl 0x3c(%rsp), %eax
xorl %ebx, %ebx
cmpq $0x3, %rax
ja 0xc430
leaq 0x17d82(%rip), %rcx     # 0x24060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xc0(%rsp), %rdi
callq 0xcb08
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
leaq 0xc0(%rsp), %rdi
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
callq 0xb8c2
movq 0xc0(%rsp), %rdi
jmp 0xc426
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
callq 0x9afc
jmp 0xc430
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0xcb08
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
leaq 0x40(%rsp), %rdi
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
callq 0xc189
movq 0x40(%rsp), %rdi
jmp 0xc426
leaq 0x110(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x100(%rsp), %rdi
callq 0xcb08
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
leaq 0x100(%rsp), %rdi
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
callq 0xb77c
movq 0x100(%rsp), %rdi
jmp 0xc426
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x80(%rsp), %rdi
callq 0xcb08
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
leaq 0x80(%rsp), %rdi
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
callq 0xb9dc
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0xc430
callq 0x6430
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xc43e
callq 0x6430
movl %ebx, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0xc47c
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
jmp 0xc47c
movq %rax, %rbx
movq 0x100(%rsp), %rdi
jmp 0xc47c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xc48b
callq 0x6430
jmp 0xc48b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xc499
callq 0x6430
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: LatMgr::GetStatistics(Lat_Stats&)
void GetStatistics(Lat_Stats &lat_stats) {
        sort(lat_vec.begin(), lat_vec.end());
        //for (vector<uint64_t>::iterator iter=lat_vec.begin(); iter!= lat_vec.end(); ++iter)
        //{
        //    cout << "sorted latency is: " << *iter << endl;
        //}
        int len = lat_vec.size();
        int med_idx = len / 2;
        int P_50_idx = (int) (len * 0.5) - 1;
        int P_75_idx = (int) (len * 0.75) - 1;
        int P_99_idx = (int) (len * 0.99) - 1;
        int P_999_idx = (int) (len * 0.999) - 1;
        int P_9999_idx = (int) (len * 0.9999) - 1;

        lat_stats.med    = lat_vec[med_idx];
        lat_stats.P_50   = lat_vec[P_50_idx];
        lat_stats.P_75   = lat_vec[P_75_idx];
        lat_stats.P_99   = lat_vec[P_99_idx];
        lat_stats.P_999  = lat_vec[P_999_idx];
        lat_stats.P_9999 = lat_vec[P_9999_idx];
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0xc580
movq %rdi, %r15
movq %r12, %rax
subq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xc7ad
movq %r14, %rdi
movq %r12, %rsi
callq 0xc896
movq (%r15), %r14
movq 0x8(%r15), %rax
jmp 0xc583
movq %r14, %rax
subq %r14, %rax
shrq $0x3, %rax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cvtsi2sd %eax, %xmm0
movsd 0x17a79(%rip), %xmm1    # 0x24018
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movslq %ecx, %rcx
movq (%r14,%rcx,8), %rcx
movq %rcx, (%rbx)
cltq
movq -0x8(%r14,%rax,8), %rax
movq %rax, 0x8(%rbx)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x17a78(%rip), %xmm1    # 0x24040
mulpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
movd %xmm1, %eax
cltq
movq -0x8(%r14,%rax,8), %rax
movq %rax, 0x10(%rbx)
pshufd $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movd %xmm1, %eax
cltq
movq -0x8(%r14,%rax,8), %rax
mulpd 0x17a59(%rip), %xmm0    # 0x24050
movq %rax, 0x18(%rbx)
cvttpd2dq %xmm0, %xmm0
movd %xmm0, %eax
cltq
movq -0x8(%r14,%rax,8), %rax
movq %rax, 0x20(%rbx)
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %eax
cltq
movq -0x8(%r14,%rax,8), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq