LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/engine.cpp
// Function: forrocket::Engine::Update(double, double, double)
void forrocket::Engine::Update(const double t, const double pressure, const double mass_prop) {
    if (t <= burn_duration && mass_prop > 0.0) {
        Ignittion();
    } else {
        Cutoff();
    }

    if (burning) {
        this->thrust = thrust_vacuum_src(t) - (pressure * area_exit);
        this->mdot_prop = mdot_prop_src(t);
    } else {
        thrust = 0.0;
        mdot_prop = 0.0;
    }

    gimbal_angle_y_axis = mis_alignment_angle_y_axis;
    gimbal_angle_z_axis = mis_alignment_angle_z_axis;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm4
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
movapd %xmm4, %xmm5
cmplepd %xmm0, %xmm5
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
cmpltpd %xmm2, %xmm3
andpd %xmm5, %xmm3
movd %xmm3, %eax
andb $0x1, %al
movb %al, (%rdi)
je 0x16ef4
leaq 0x58(%rbx), %rdi
movapd %xmm4, %xmm0
movapd %xmm4, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x1526a
movsd 0x8(%rsp), %xmm1
mulsd 0x38(%rbx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
leaq 0xf8(%rbx), %rdi
movapd 0x10(%rsp), %xmm0
callq 0x1526a
jmp 0x16ef9
andq $0x0, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/flight_data_recorder.cpp
// Function: forrocket::FlightDataRecorder::ReserveCapacity(int)
void forrocket::FlightDataRecorder::ReserveCapacity(const int capacity) {
    countup_time.reserve(capacity);
    countup_burn_time.reserve(capacity);
    thrust.reserve(capacity);
    mdot_prop.reserve(capacity);
    burning.reserve(capacity);
    gimbal_angle_y_axis.reserve(capacity);
    gimbal_angle_z_axis.reserve(capacity);
    mass_prop.reserve(capacity);
    mass.reserve(capacity);
    length_CG.reserve(capacity);
    length_CP.reserve(capacity);
    inertia_tensor.reserve(capacity);
    CA.reserve(capacity);
    CNa.reserve(capacity);
    Cld.reserve(capacity);
    Clp.reserve(capacity);
    Cmq.reserve(capacity);
    position.reserve(capacity);
    velocity.reserve(capacity);
    dynamic_pressure.reserve(capacity);
    acceleration.reserve(capacity);
    force.reserve(capacity);
    attitude.reserve(capacity);
    quaternion_dot.reserve(capacity);
    angular_velocity.reserve(capacity);
    angular_acceleration.reserve(capacity);
    angle_of_attack.reserve(capacity);
    sideslip_angle.reserve(capacity);
    moment.reserve(capacity);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
movslq %esi, %r14
movq %r14, %rsi
callq 0x19258
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x192ee
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x108(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x19320
leaq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x150(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x168(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x180(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x198(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x1b0(%rbx), %rdi
movq %r14, %rsi
callq 0x193e2
leaq 0x1c8(%rbx), %rdi
movq %r14, %rsi
callq 0x194cc
leaq 0x1e0(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x1f8(%rbx), %rdi
movq %r14, %rsi
callq 0x1956e
leaq 0x210(%rbx), %rdi
movq %r14, %rsi
callq 0x19644
leaq 0x228(%rbx), %rdi
movq %r14, %rsi
callq 0x1972e
leaq 0x240(%rbx), %rdi
movq %r14, %rsi
callq 0x197ee
leaq 0x258(%rbx), %rdi
movq %r14, %rsi
callq 0x1989e
leaq 0x270(%rbx), %rdi
movq %r14, %rsi
callq 0x1989e
leaq 0x288(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
leaq 0x2a0(%rbx), %rdi
movq %r14, %rsi
callq 0x19258
addq $0x2b8, %rbx            # imm = 0x2B8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19964
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getClp(double)
double forrocket::Rocket::getClp(const double mach_number) {
    this->Clp = Clp_src(mach_number);
    if (this->Clp > 0.0) {
        this->Clp *= -1.0;
    }
    return this->Clp;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0xc70, %rdi            # imm = 0xC70
callq 0x1526a
movapd 0x163f0(%rip), %xmm1    # 0x31930
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x280(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getCmq(double)
double forrocket::Rocket::getCmq(const double mach_number) {
    this->Cmq = Cmq_src(mach_number);
    if (this->Cmq > 0.0) {
        this->Cmq *= -1.0;
    }
    return this->Cmq;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0xd10, %rdi            # imm = 0xD10
callq 0x1526a
movapd 0x163c2(%rip), %xmm1    # 0x31930
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x288(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getCnr(double)
double forrocket::Rocket::getCnr(const double mach_number) {
    this->Cnr = Cnr_src(mach_number);
    if (this->Cnr > 0.0) {
        this->Cnr *= -1.0;
    }
    return this->Cnr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0xdb0, %rdi            # imm = 0xDB0
callq 0x1526a
movapd 0x16394(%rip), %xmm1    # 0x31930
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x290(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getThrust(double)
Eigen::Vector3d forrocket::Rocket::getThrust(const double air_pressure) {
    engine.Update(burn_clock.countup_time, air_pressure, mass.propellant);

    Eigen::Vector3d thrust;
    if (engine.burning) {
        Eigen::Vector3d gimbal_angle(std::cos(engine.gimbal_angle_y_axis) * std::cos(engine.gimbal_angle_y_axis),
                                    std::sin(engine.gimbal_angle_z_axis),
                                    -std::sin(engine.gimbal_angle_y_axis));
        thrust << engine.thrust * gimbal_angle.array();
    } else {
        thrust << 0.0, 0.0, 0.0;
    }

    return thrust;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps %xmm0, %xmm1
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsi), %rdi
movsd 0x38(%rsi), %xmm0
movsd 0x218(%rsi), %xmm2
callq 0x16e7e
cmpb $0x1, 0x48(%r14)
jne 0x1b685
movsd 0x70(%r14), %xmm0
callq 0x5610
movsd %xmm0, 0x8(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x5610
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x78(%r14), %xmm0
callq 0x50e0
movsd %xmm0, 0x10(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x50e0
xorps 0x162fd(%rip), %xmm0    # 0x31930
leaq 0x48(%rsp), %rax
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%rax)
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x8(%rax)
movlps %xmm0, 0x10(%rax)
addq $0x58, %r14
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ba9b
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1bb8c
movq %r14, %rdi
jmp 0x1b6c5
leaq 0x20(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, (%rbx)
leaq 0x48(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x126a8
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x20(%rsp), %rdi
callq 0x12750
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1b6dc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getInertiaTensor()
Eigen::Matrix3d forrocket::Rocket::getInertiaTensor() {
    if (engine.burning) {
        Eigen::Matrix3d tensor;
        double t = burn_clock.countup_time;
        tensor << inertia_moment_xx_src(t), 0.0, 0.0,
                0.0, inertia_moment_yy_src(t), 0.0,
                0.0, 0.0, inertia_moment_zz_src(t);
        this->inertia_tensor = tensor;
    }
    return this->inertia_tensor;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x48(%rsi)
jne 0x1b80e
movsd 0x38(%r14), %xmm0
leaq 0x4f0(%r14), %rdi
movsd %xmm0, (%rsp)
callq 0x1526a
leaq 0x68(%rsp), %rax
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rcx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movsd %xmm0, (%rax)
leaq 0x40(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x12584
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x30(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movq %rax, %r15
leaq 0x590(%r14), %rdi
movsd (%rsp), %xmm0
callq 0x1526a
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x12584
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movq %rax, %r15
leaq 0x630(%r14), %rdi
movsd (%rsp), %xmm0
callq 0x1526a
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x12584
leaq 0x48(%rsp), %rdi
callq 0x1262c
leaq 0x220(%r14), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1bf84
addq $0x220, %r14            # imm = 0x220
pushq $0x9
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1b83f
jmp 0x1b83f
jmp 0x1b83f
jmp 0x1b83f
jmp 0x1b83f
jmp 0x1b83f
jmp 0x1b83f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1262c
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getAttitude()
Eigen::Vector3d forrocket::Rocket::getAttitude() {
    Eigen::Vector3d attitude;
    double t = burn_clock.countup_time;
    attitude << azimuth_program_src(t), elevation_program_src(t), roll_program_src(t);
    return attitude;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x6d0(%rsi), %rdi
callq 0x1526a
movq %rbx, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
pushq $0x1
popq %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movsd %xmm0, (%rbx)
leaq 0x770(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1526a
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x126a8
movq %rax, %r15
addq $0x810, %r14            # imm = 0x810
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1526a
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x126a8
leaq 0x10(%rsp), %rdi
callq 0x12750
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1b8fd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x158bc(%rip), %xmm1    # 0x31930
mulsd 0x268(%rdx), %xmm1
mulsd %xmm0, %xmm3
movsd 0x468(%rdx), %xmm2
movapd %xmm3, 0x10(%rsp)
mulsd %xmm3, %xmm2
leaq 0x28(%rsp), %rsi
movsd %xmm2, (%rsi)
movsd 0x460(%rdx), %xmm2
movsd %xmm2, 0x8(%rsp)
mulsd %xmm0, %xmm1
leaq 0x30(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd %xmm1, (%rbx)
callq 0x126a8
movapd 0x10(%rsp), %xmm0
xorpd 0x15854(%rip), %xmm0    # 0x31930
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
leaq 0x20(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x30(%rsp), %rdi
callq 0x12750
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x1c10c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x1b6f2
addq $0x430, %r14            # imm = 0x430
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x1c8b0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1c60c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x1496a
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x1c651
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c974
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movsd 0x200(%rdx), %xmm0
subsd 0x1e0(%rdx), %xmm0
leaq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rax)
leaq 0x388(%rdx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x1c60c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1496a
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movsd 0x200(%rdx), %xmm0
subsd 0x208(%rdx), %xmm0
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rdx)
leaq 0x3a0(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x1c60c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1496a
movsd 0x350(%r14), %xmm0
mulsd 0x278(%r14), %xmm0
mulsd 0x1f0(%r14), %xmm0
mulsd 0x1f8(%r14), %xmm0
mulsd 0x298(%r14), %xmm0
mulsd 0x156ab(%rip), %xmm0    # 0x31950
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %r14
movq %rdi, %rbx
movups 0x280(%rdx), %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movsd 0x290(%rdx), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x350(%rdx), %rsi
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x1ba9b
leaq 0x1f0(%r14), %rdx
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c69e
movsd 0x1f8(%r14), %xmm0
mulsd %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c6fa
leaq 0x330(%r14), %rdi
callq 0x1c7d2
addsd %xmm0, %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x110(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c760
addq $0x430, %r14            # imm = 0x430
movsd 0x28(%r12), %xmm0
leaq 0x198(%rsp), %rsi
movsd %xmm0, 0x30(%rsi)
movq 0x30(%r12), %rax
movq %rax, 0x38(%rsi)
movsd 0x48(%r12), %xmm0
movsd %xmm0, 0x50(%rsi)
movsd 0x60(%r12), %xmm0
movsd %xmm0, 0x68(%rsi)
movsd 0x78(%r12), %xmm0
movsd %xmm0, 0x80(%rsi)
movq %r14, 0x90(%rsi)
movq %rbx, %rdi
callq 0x1ca54
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd 0x440(%rdx), %xmm0
leaq 0x80(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
pushq $0x1
popq %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
andq $0x0, (%rbx)
callq 0x1c7f8
movaps 0x20(%rsp), %xmm0
xorps 0x1547d(%rip), %xmm0    # 0x31930
leaq 0x78(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1c7f8
movsd 0x10(%rsp), %xmm0
xorps 0x15453(%rip), %xmm0    # 0x31930
leaq 0x70(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x68(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1c7f8
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1c7f8
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1c7f8
movsd 0x8(%rsp), %xmm0
xorps 0x153fe(%rip), %xmm0    # 0x31930
leaq 0x60(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x58(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1c7f8
movsd 0x8(%rsp), %xmm0
xorps 0x153c3(%rip), %xmm0    # 0x31930
leaq 0x50(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
movsd 0x18(%rsp), %xmm0
xorps 0x153a6(%rip), %xmm0    # 0x31930
leaq 0x48(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
movsd 0x10(%rsp), %xmm0
xorps 0x15389(%rip), %xmm0    # 0x31930
leaq 0x40(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1c7f8
leaq 0x80(%rsp), %rdi
callq 0x1c8a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
retq
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
jmp 0x1c5f3
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1c8a0
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movsd 0x350(%rdx), %xmm0
xorpd 0x14c90(%rip), %xmm0    # 0x31930
mulsd 0x268(%rdx), %xmm0
mulsd 0x1f0(%rdx), %xmm0
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
andq $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd %xmm0, (%rbx)
callq 0x126a8
movq %rsp, %rsi
movq %rax, %rdi
callq 0x126a8
leaq 0x10(%rsp), %rdi
callq 0x12750
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d6a0
fstp %st(0)
movq %rbx, %rdi
callq 0x1d7b2
fstp %st(0)
movq %rbx, %rdi
callq 0x1d8c4
fstp %st(0)
movq %rbx, %rdi
callq 0x1d9fc
fstp %st(0)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/Eigen/src/LU/InverseImpl.h
// Function: Eigen::internal::compute_inverse<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3>::run(Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&)
EIGEN_DEVICE_FUNC
  static inline void run(const MatrixType& matrix, ResultType& result)
  {
    typedef typename ResultType::Scalar Scalar;
    Matrix<typename MatrixType::Scalar,3,1> cofactors_col0;
    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
    const Scalar det = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
    const Scalar invdet = Scalar(1) / det;
    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x30(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
movupd 0x38(%rdi), %xmm2
movupd 0x20(%rdi), %xmm3
movapd %xmm3, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd %xmm2, %xmm4
mulsd %xmm2, %xmm1
shufpd $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1],xmm0[0]
mulpd %xmm3, %xmm2
subpd %xmm4, %xmm2
movq %rsp, %r15
movapd %xmm2, (%r15)
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, 0x10(%r15)
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x20318
leaq 0x20(%rsp), %r13
movq %r15, (%r13)
movq (%r12), %rax
movq %rax, 0x8(%r13)
movups 0x10(%r12), %xmm0
movups %xmm0, 0x18(%r13)
movupd 0x20(%r12), %xmm0
movupd %xmm0, 0x28(%r13)
movq %r13, %rdi
callq 0x201d8
movsd 0x11797(%rip), %xmm1    # 0x31940
divsd %xmm0, %xmm1
movsd %xmm1, (%r13)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x201e5
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/Eigen/src/LU/InverseImpl.h
// Function: void Eigen::internal::compute_inverse_size3_helper<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 3, 0, 3, 3>>(Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>::Scalar const&, Eigen::Matrix<Eigen::Matrix<double, 3, 3, 0, 3, 3>::Scalar, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&)
EIGEN_DEVICE_FUNC
inline void compute_inverse_size3_helper(
    const MatrixType& matrix,
    const typename ResultType::Scalar& invdet,
    const Matrix<typename ResultType::Scalar,3,1>& cofactors_col0,
    ResultType& result)
{
  result.row(0) = cofactors_col0 * invdet;
  result.coeffRef(1,0) =  cofactor_3x3<MatrixType,0,1>(matrix) * invdet;
  result.coeffRef(1,1) =  cofactor_3x3<MatrixType,1,1>(matrix) * invdet;
  result.coeffRef(1,2) =  cofactor_3x3<MatrixType,2,1>(matrix) * invdet;
  result.coeffRef(2,0) =  cofactor_3x3<MatrixType,0,2>(matrix) * invdet;
  result.coeffRef(2,1) =  cofactor_3x3<MatrixType,1,2>(matrix) * invdet;
  result.coeffRef(2,2) =  cofactor_3x3<MatrixType,2,2>(matrix) * invdet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x20464
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x204b0
movq %r13, %rdi
movq %r12, %rsi
callq 0x20556
movsd 0x38(%r15), %xmm0
movsd 0x40(%r15), %xmm1
mulsd 0x8(%r15), %xmm1
mulsd 0x10(%r15), %xmm0
subsd %xmm1, %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x30(%r15), %xmm0
movsd 0x40(%r15), %xmm1
mulsd 0x10(%r15), %xmm0
mulsd (%r15), %xmm1
subsd %xmm0, %xmm1
mulsd (%r14), %xmm1
movsd %xmm1, 0x20(%rbx)
movsd 0x30(%r15), %xmm0
movsd 0x38(%r15), %xmm1
mulsd (%r15), %xmm1
mulsd 0x8(%r15), %xmm0
subsd %xmm1, %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd 0x8(%r15), %xmm0
movsd 0x10(%r15), %xmm1
mulsd 0x20(%r15), %xmm1
mulsd 0x28(%r15), %xmm0
subsd %xmm1, %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd (%r15), %xmm0
movsd 0x10(%r15), %xmm1
mulsd 0x28(%r15), %xmm0
mulsd 0x18(%r15), %xmm1
subsd %xmm0, %xmm1
mulsd (%r14), %xmm1
movsd %xmm1, 0x28(%rbx)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd 0x18(%r15), %xmm1
mulsd 0x20(%r15), %xmm0
subsd %xmm1, %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x20
popq %rdi
callq 0x5330
movsd 0x10(%rsp), %xmm0
movq %rax, %rbx
addq $0x10, %r13
cmpb $0x1, %bpl
jne 0x2652b
ucomisd 0x8(%rsp), %xmm0
jb 0x2652b
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2652b
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x20b6c
jmp 0x2653c
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1f2f0
movq %rbx, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26550
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x5340
movq %r14, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl %edx, %eax
jge 0x28232
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
leaq 0xd73f(%rip), %rsi      # 0x35978
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50b0
leaq 0x20(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72de
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x28fe6
leaq 0xd74e(%rip), %rsi      # 0x359bf
leaq 0xd786(%rip), %rdx      # 0x359fe
leaq 0x10(%rsp), %rdi
pushq $0x69
popq %rcx
callq 0x28f9a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5380
jmp 0x28297
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5688
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x3ba, %rdi            # imm = 0x3BA
leaq 0xe8(%rip), %rax        # 0x28476
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq %r14, %rsi
callq 0x28344
leaq 0x3bb(%r15), %rdi
leaq 0xc5(%rip), %rax        # 0x2847a
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq %r14, %rsi
callq 0x28344
leaq 0x4a0(%r15), %rbp
leaq 0x510(%r15), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rbx
movq %r12, %rcx
movq 0x8(%rsp), %r8
movq %rbp, %r9
pushq 0x10(%rsp)
pushq %r13
callq 0x2847e
popq %rcx
popq %rdx
movl %eax, %r15d
testl %eax, %eax
jne 0x28427
pushq $0x70
popq %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x5520
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5520
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/boost/numeric/odeint/integrate/detail/integrate_const.hpp
// Function: unsigned long boost::numeric::odeint::detail::integrate_const<boost::numeric::odeint::runge_kutta4<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>, forrocket::Dynamics3dofParachute, std::array<double, 14ul>, double, std::reference_wrapper<forrocket::FlightDataRecorder>>(boost::numeric::odeint::runge_kutta4<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>, forrocket::Dynamics3dofParachute, std::array<double, 14ul>&, double, double, double, std::reference_wrapper<forrocket::FlightDataRecorder>, boost::numeric::odeint::stepper_tag)
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , stepper_tag
)
{

    typename odeint::unwrap_reference< Observer >::type &obs = observer;
    typename odeint::unwrap_reference< Stepper >::type &st = stepper;

    Time time = start_time;
    int step = 0;
    // cast time+dt explicitely in case of expression templates (e.g. multiprecision)
    while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) )
    {
        obs( start_state , time );
        st.do_step( system , start_state , time , dt );
        // direct computation of the time avoids error propagation happening when using time += dt
        // we need clumsy type analysis to get boost units working here
        ++step;
        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
    }
    obs( start_state , time );

    return step;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x18(%rsp)
movsd %xmm2, (%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x8, %r15
xorl %r13d, %r13d
leaq 0x1f2e8(%rip), %rbx     # 0x48928
addq $0x10, %rbx
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm4
movsd (%rsp), %xmm2
addsd %xmm2, %xmm4
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
subsd %xmm4, %xmm1
subsd %xmm3, %xmm4
xorl %eax, %eax
movsd 0xc215(%rip), %xmm3     # 0x35888
ucomisd %xmm4, %xmm3
setae %al
xorl %ebp, %ebp
ucomisd %xmm1, %xmm3
setae %bpl
ucomisd 0x9264(%rip), %xmm2     # 0x328f0
cmoval %eax, %ebp
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movsd %xmm0, 0x20(%rsp)
callq 0x17126
cmpb $0x1, %bpl
jne 0x296f4
movq %rbx, 0x28(%rsp)
movq 0x10(%r15), %rax
leaq 0x30(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
movsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x29706
incq %r13
cvtsi2sd %r13d, %xmm0
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
jmp 0x2964a
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
// Function: void boost::numeric::odeint::explicit_stepper_base<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>, (unsigned short)4, 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_v1<forrocket::Dynamics3dofParachute, std::array<double, 14ul>>(forrocket::Dynamics3dofParachute, std::array<double, 14ul>&, double, double)
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
    {
        typename odeint::unwrap_reference< System >::type &sys = system;
        m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
        sys( x , m_dxdt.m_v ,t );
        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
incq %rdi
leaq 0x91(%rip), %rax        # 0x297f4
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq %rbx, %rsi
callq 0x297e0
leaq 0x8(%r14), %r12
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movsd (%rsp), %xmm0
callq *(%rax)
leaq 0x1f18e(%rip), %rax     # 0x48928
addq $0x10, %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsi)
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movsd (%rsp), %xmm0
movq %rbx, %r8
movsd 0x8(%rsp), %xmm1
callq 0x297f8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/boost/fusion/algorithm/iteration/detail/for_each.hpp
// Function: void boost::fusion::detail::for_each_unrolled<4>::call<boost::fusion::vector_iterator<boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector const, 0>, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::calculate_stage<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, boost::numeric::odeint::state_wrapper<std::array<double, 14ul>, void>, std::array<double, 14ul>, double>>(boost::fusion::vector_iterator<boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector const, 0> const&, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::calculate_stage<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, boost::numeric::odeint::state_wrapper<std::array<double, 14ul>, void>, std::array<double, 14ul>, double>&)
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        static void call(I0 const& i0, F& f)
        {
            f(*i0);
            typedef typename result_of::next<I0>::type I1;
            I1 i1(fusion::next(i0));
            f(*i1);
            typedef typename result_of::next<I1>::type I2;
            I2 i2(fusion::next(i1));
            f(*i2);
            typedef typename result_of::next<I2>::type I3;
            I3 i3(fusion::next(i2));
            f(*i3);
            for_each_unrolled<N-4>::call(fusion::next(i3), f);
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
movq %rbx, %rdi
callq 0x299da
movq (%r14), %r14
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x29a04
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x29a88
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29b26
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
// Function: void boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::calculate_stage<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, boost::numeric::odeint::state_wrapper<std::array<double, 14ul>, void>, std::array<double, 14ul>, double>::operator()<double, 4ul>(boost::numeric::odeint::detail::stage<double, 4ul> const&) const
void inline operator()( stage< T , stage_number > const &stage ) const
        //typename stage_fusion_wrapper< T , mpl::size_t< stage_number > , intermediate_stage >::type const &stage ) const
        {
            if( stage_number > 1 )
            {
#ifdef BOOST_MSVC
#pragma warning( disable : 4307 34 )
#endif
                system( x_tmp , F[stage_number-2].m_v , t + stage.c * dt );
#ifdef BOOST_MSVC
#pragma warning( default : 4307 34 )
#endif
            }
            //std::cout << stage_number-2 << ", t': " << t + stage.c * dt << std::endl;

            if( stage_number < StageCount )
                detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_tmp , x , dxdt , F ,
                        detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt) );
            //                  algebra_type::template for_eachn<stage_number>( x_tmp , x , dxdt , F ,
            //                          typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) );
            else
                detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_out , x , dxdt , F ,
                        detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt ) );
            //                algebra_type::template for_eachn<stage_number>( x_out , x , dxdt , F ,
            //                            typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) );
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xe0, %edx
addq 0x30(%rdi), %rdx
movq 0x8(%rdi), %rdi
movsd (%rsi), %xmm0
mulsd 0x40(%r14), %xmm0
movq 0x18(%r14), %rsi
addsd 0x38(%r14), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rsi
movsd 0x40(%r14), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd 0x10(%rbx), %xmm2
mulsd %xmm0, %xmm2
movsd 0x18(%rbx), %xmm3
mulsd %xmm0, %xmm3
mulsd 0x20(%rbx), %xmm0
xorl %edi, %edi
cmpq $0xe, %rdi
je 0x29bd8
movsd (%rdx,%rdi,8), %xmm4
mulsd %xmm1, %xmm4
addsd (%rax,%rdi,8), %xmm4
movsd (%rsi,%rdi,8), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
movsd 0x70(%rsi,%rdi,8), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm5, %xmm4
movsd 0xe0(%rsi,%rdi,8), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, (%rcx,%rdi,8)
incq %rdi
jmp 0x29b8e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq 0x2d501(%rip), %rdi     # 0x33fd0
leaq 0x19645(%rip), %rsi     # 0x2011b
callq 0x6420
movq %rax, %rdi
callq 0x61c0
shll $0xa, %r14d
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x168f4
movl %r15d, 0x40(%r13)
movl %r14d, 0x44(%r13)
movl %ebp, 0x18(%r13)
movl %ebx, 0x3c(%r13)
leaq 0x68(%rsp), %rdi
callq 0x1f856
movq (%r12), %rax
pushq $0xa
popq %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x12944
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1f856
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1f8c2
movq %rax, %r14
movq 0x2d484(%rip), %rdi     # 0x33fd0
leaq 0x195e8(%rip), %rsi     # 0x2013b
callq 0x6420
cvtsi2sd %r14, %xmm0
divsd 0x194a3(%rip), %xmm0    # 0x20008
movq %rax, %rdi
callq 0x6650
leaq 0x1983e(%rip), %rsi     # 0x203b2
movq %rax, %rdi
callq 0x6420
movq %rax, %rdi
callq 0x61c0
testq %rbx, %rbx
je 0x6b96
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x6b99
pushq $-0x1
popq %rbx
leaq 0x58(%rsp), %rdi
callq 0x1f8dc
leaq 0x68(%rsp), %rdi
callq 0x1f8dc
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bc3
movq %rax, %rbx
jmp 0x6bd5
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1f8dc
leaq 0x68(%rsp), %rdi
callq 0x1f8dc
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x2d3ce(%rip), %rdi     # 0x33fd0
leaq 0x19547(%rip), %rsi     # 0x20150
callq 0x6420
movq %rax, %rdi
callq 0x61c0
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x168f4
movl %ebp, 0x18(%r15)
testl %ebx, %ebx
setne 0x38(%r15)
leaq 0x68(%rsp), %rdi
callq 0x1f856
movq (%r14), %rax
pushq $0xa
popq %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x12c5c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1f856
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1f8c2
movq %rax, %r14
movq 0x2d35b(%rip), %rdi     # 0x33fd0
leaq 0x194f2(%rip), %rsi     # 0x2016e
callq 0x6420
cvtsi2sd %r14, %xmm0
divsd 0x1937a(%rip), %xmm0    # 0x20008
movq %rax, %rdi
callq 0x6650
leaq 0x19715(%rip), %rsi     # 0x203b2
movq %rax, %rdi
callq 0x6420
movq %rax, %rdi
callq 0x61c0
leaq 0x58(%rsp), %rdi
callq 0x1f8dc
leaq 0x68(%rsp), %rdi
callq 0x1f8dc
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6cd4
movq %rax, %rbx
jmp 0x6ce6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1f8dc
leaq 0x68(%rsp), %rdi
callq 0x1f8dc
movq %rbx, %rdi
callq 0x66f0