LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/rocket/engine.cpp
// Function: forrocket::Engine::Engine(double, double, double, double, double, double)
forrocket::Engine::Engine(const double burn_duration, const double thrust_const, const double mdot_prop_const, const double area_exit,
                    const double mis_alignment_angle_y_axis, const double mis_alignment_angle_z_axis) {
    Reset();
    enable_gimbal = false;

    this->area_exit = area_exit;

    this->burn_duration = burn_duration;
    thrust_vacuum_src = InterpolateParameter(thrust_const);
    mdot_prop_src = InterpolateParameter(mdot_prop_const);
    this->mis_alignment_angle_y_axis = mis_alignment_angle_y_axis;
    this->mis_alignment_angle_z_axis = mis_alignment_angle_z_axis;

    getTotalImpulse(thrust_const, burn_duration);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movsd %xmm5, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movb $0x0, (%rdi)
leaq 0x58(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x41(%rdi)
movq %r14, %rdi
callq 0x19934
leaq 0xf8(%rbx), %r15
movq %r15, %rdi
callq 0x19934
leaq 0x8(%rbx), %rax
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x41(%rbx)
movups %xmm0, 0x28(%rbx)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
leaq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1996a
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x19cc2
movq 0xb0(%rsp), %rdi
callq 0x53d0
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2a0
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2bd
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2d4
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2eb
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
leaq 0x30(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x1996a
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x19cc2
movq 0xb0(%rsp), %rdi
callq 0x53d0
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1b332
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1b34f
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1b366
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1b37d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x48(%rbx)
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1b3b4
jmp 0x1b3c3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x18cce
jmp 0x1b3c6
movq %rax, %rbx
movq %r15, %rdi
callq 0x18cce
jmp 0x1b3d3
movq %rax, %rbx
movq %r14, %rdi
callq 0x18cce
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm3
movapd %xmm0, %xmm4
cmplepd %xmm3, %xmm4
xorpd %xmm3, %xmm3
cmpltpd %xmm2, %xmm3
andpd %xmm4, %xmm3
movd %xmm3, %eax
andb $0x1, %al
movb %al, (%rdi)
je 0x1bdcb
leaq 0x58(%rbx), %rdi
movapd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x19d4e
movsd 0x8(%rsp), %xmm1
mulsd 0x38(%rbx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
leaq 0xf8(%rbx), %rdi
movapd 0x10(%rsp), %xmm0
callq 0x19d4e
movsd %xmm0, 0x18(%rbx)
jmp 0x1bdd4
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rbx)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e996
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x1ea2c
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x108(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x1ea5e
leaq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x150(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x168(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x180(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x198(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x1b0(%rbx), %rdi
movq %r14, %rsi
callq 0x1eb22
leaq 0x1c8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ec18
leaq 0x1e0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x1f8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ed2c
leaq 0x210(%rbx), %rdi
movq %r14, %rsi
callq 0x1ee12
leaq 0x228(%rbx), %rdi
movq %r14, %rsi
callq 0x1ef08
leaq 0x240(%rbx), %rdi
movq %r14, %rsi
callq 0x1efd6
leaq 0x258(%rbx), %rdi
movq %r14, %rsi
callq 0x1f086
leaq 0x270(%rbx), %rdi
movq %r14, %rsi
callq 0x1f086
leaq 0x288(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
leaq 0x2a0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e996
addq $0x2b8, %rbx            # imm = 0x2B8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f14a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19d4e
movapd 0x19844(%rip), %xmm1    # 0x3a6d0
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x280(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19d4e
movapd 0x19816(%rip), %xmm1    # 0x3a6d0
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x288(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19d4e
movapd 0x197e8(%rip), %xmm1    # 0x3a6d0
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x290(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movapd %xmm0, %xmm1
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsi), %rdi
movsd 0x38(%rsi), %xmm0
movsd 0x218(%rsi), %xmm2
callq 0x1bd5c
cmpb $0x1, 0x48(%r14)
jne 0x20fcf
movsd 0x70(%r14), %xmm0
callq 0x5640
movsd %xmm0, 0x8(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x5640
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x78(%r14), %xmm0
callq 0x50e0
movsd %xmm0, 0x8(%rsp)
movsd 0x70(%r14), %xmm0
callq 0x50e0
movsd 0x30(%rsp), %xmm2
xorpd 0x1974e(%rip), %xmm0    # 0x3a6d0
movsd %xmm2, 0x10(%rsp)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movlpd %xmm0, 0x20(%rsp)
movsd 0x58(%r14), %xmm1
movl %ebx, %eax
shrl $0x3, %eax
andl $0x1, %eax
jne 0x21028
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shll $0x3, %eax
movupd 0x10(%rsp,%rax), %xmm3
mulpd %xmm2, %xmm3
movapd %xmm3, (%rbx,%rax)
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
jmp 0x21046
leaq 0x10(%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)
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
callq 0x1726a
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x21073
cmpq $0x1, 0x20(%rsp)
je 0x21046
jmp 0x21073
mulsd %xmm1, %xmm2
movsd %xmm2, (%rbx)
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
shll $0x3, %eax
movupd 0x10(%rsp,%rax), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, (%rbx,%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x21053
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x21073
cmpq $0x1, 0x20(%rsp)
jne 0x21073
movq %rax, %rdi
callq 0x55e0
leaq 0x19696(%rip), %rdi     # 0x3a710
leaq 0x1972d(%rip), %rsi     # 0x3a7ae
leaq 0x19918(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x48(%rsi)
jne 0x21216
movsd 0x38(%r14), %xmm0
leaq 0x4f0(%r14), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x19d4e
leaq 0x70(%rsp), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movsd %xmm0, (%rax)
leaq 0x68(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x171ac
leaq 0x60(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
leaq 0x58(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
movq %rax, %r15
leaq 0x590(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x19d4e
leaq 0x50(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x171ac
leaq 0x48(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
leaq 0x40(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
movq %rax, %r15
leaq 0x630(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x19d4e
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x171ac
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x21269
cmpq $0x3, 0x20(%rsp)
jne 0x21269
movaps 0x70(%rsp), %xmm0
movaps %xmm0, 0x220(%r14)
movaps 0x80(%rsp), %xmm0
movaps %xmm0, 0x230(%r14)
movaps 0x90(%rsp), %xmm0
movaps %xmm0, 0x240(%r14)
movaps 0xa0(%rsp), %xmm0
movaps %xmm0, 0x250(%r14)
movsd 0xb0(%rsp), %xmm0
movsd %xmm0, 0x260(%r14)
addq $0x220, %r14            # imm = 0x220
movl $0x9, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21249
jmp 0x21249
jmp 0x21249
jmp 0x21249
jmp 0x21249
jmp 0x21249
jmp 0x21249
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x21269
cmpq $0x3, 0x20(%rsp)
jne 0x21269
movq %rax, %rdi
callq 0x55e0
leaq 0x194a0(%rip), %rdi     # 0x3a710
leaq 0x19537(%rip), %rsi     # 0x3a7ae
leaq 0x19558(%rip), %rcx     # 0x3a7d6
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19d4e
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movsd %xmm0, (%rbx)
leaq 0x770(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x19d4e
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1726a
movq %rax, %r15
addq $0x810, %r14            # imm = 0x810
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x19d4e
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x1726a
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x21364
cmpq $0x1, 0x20(%rsp)
jne 0x21364
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21344
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x21364
cmpq $0x1, 0x20(%rsp)
jne 0x21364
movq %rax, %rdi
callq 0x55e0
leaq 0x193a5(%rip), %rdi     # 0x3a710
leaq 0x1943c(%rip), %rsi     # 0x3a7ae
leaq 0x19627(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1909c(%rip), %xmm1    # 0x3a6d0
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 0x1726a
movapd 0x30(%rsp), %xmm0
xorpd 0x1902f(%rip), %xmm0    # 0x3a6d0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
leaq 0x40(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x216ff
cmpq $0x1, 0x20(%rsp)
jne 0x216ff
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x216df
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x216ff
cmpq $0x1, 0x20(%rsp)
jne 0x216ff
movq %rax, %rdi
callq 0x55e0
leaq 0x1900a(%rip), %rdi     # 0x3a710
leaq 0x190a1(%rip), %rsi     # 0x3a7ae
leaq 0x1928c(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xf8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x21092
leaq 0x430(%r14), %rax
movsd 0x430(%r14), %xmm0
movsd 0x438(%r14), %xmm1
movsd 0x440(%r14), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%r15), %xmm0
movupd 0x18(%r15), %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
addpd %xmm0, %xmm1
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd 0x30(%r15), %xmm3
addpd %xmm1, %xmm3
movapd %xmm3, (%rsp)
leaq 0x20(%rsp), %rcx
leaq 0x90(%rsp), %r12
movq %rcx, (%r12)
movq %r15, 0x10(%r12)
movq $0x2, 0x18(%r12)
xorl %ecx, %ecx
movq %rcx, 0x20(%r12)
movq $0x1, 0x28(%r12)
movq %rax, 0x30(%r12)
movq %rax, 0x40(%r12)
movq %rcx, 0x48(%r12)
movq $0x3, 0x58(%r12)
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a6c6
movq %r12, 0x30(%r15)
movq 0x10(%r15), %rax
movq 0x20(%r15), %rcx
movsd (%rax), %xmm0
movsd 0x18(%rax), %xmm1
mulsd (%rcx), %xmm0
mulsd 0x8(%rcx), %xmm1
movsd 0x30(%rax), %xmm2
mulsd 0x10(%rcx), %xmm2
addsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd 0x430(%r14), %xmm1
movsd 0x438(%r14), %xmm3
movsd 0x440(%r14), %xmm4
movapd (%rsp), %xmm6
movapd %xmm6, %xmm0
unpckhpd %xmm6, %xmm0            # xmm0 = xmm0[1],xmm6[1]
movapd %xmm0, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm6, %xmm4
mulsd %xmm3, %xmm6
mulsd %xmm2, %xmm3
subsd %xmm5, %xmm3
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm4
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulsd %xmm1, %xmm0
subsd %xmm6, %xmm0
movapd 0x18e5b(%rip), %xmm1    # 0x3a6d0
xorpd %xmm1, %xmm3
movupd %xmm3, (%rbx)
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subsd 0x1e0(%rdx), %xmm0
movsd 0x388(%rdx), %xmm1
movsd 0x390(%rdx), %xmm2
movsd 0x398(%rdx), %xmm3
movsd 0x1a4c5(%rip), %xmm4    # 0x3bd90
movapd %xmm3, %xmm5
mulsd %xmm4, %xmm5
xorpd %xmm6, %xmm6
mulsd %xmm0, %xmm3
mulsd %xmm2, %xmm0
mulsd %xmm6, %xmm2
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm4
addsd %xmm4, %xmm3
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulsd %xmm6, %xmm1
subsd %xmm0, %xmm1
movupd %xmm2, (%rdi)
movsd %xmm1, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subsd 0x208(%rdx), %xmm0
movsd 0x3a0(%rdx), %xmm1
movsd 0x3a8(%rdx), %xmm2
movsd 0x3b0(%rdx), %xmm3
movsd 0x1a457(%rip), %xmm4    # 0x3bd90
movapd %xmm3, %xmm5
mulsd %xmm4, %xmm5
xorpd %xmm6, %xmm6
mulsd %xmm0, %xmm3
mulsd %xmm2, %xmm0
mulsd %xmm6, %xmm2
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm4
addsd %xmm4, %xmm3
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulsd %xmm6, %xmm1
subsd %xmm0, %xmm1
movupd %xmm2, (%rdi)
movsd %xmm1, 0x10(%rdi)
movsd 0x350(%rdx), %xmm0
mulsd 0x278(%rdx), %xmm0
mulsd 0x1f0(%rdx), %xmm0
mulsd 0x1f8(%rdx), %xmm0
mulsd 0x298(%rdx), %xmm0
mulsd 0x18d56(%rip), %xmm0    # 0x3a6f8
movsd %xmm0, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movupd 0x280(%rdx), %xmm3
movsd 0x350(%rdx), %xmm0
movsd 0x1f0(%rdx), %xmm2
movsd 0x1f8(%rdx), %xmm1
mulsd %xmm1, %xmm1
movupd 0x330(%rdx), %xmm4
mulpd %xmm4, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
movsd 0x340(%rdx), %xmm4
mulsd %xmm4, %xmm4
addsd %xmm5, %xmm4
sqrtsd %xmm4, %xmm4
addsd %xmm4, %xmm4
movapd %xmm0, %xmm5
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
mulsd 0x290(%rdx), %xmm0
mulpd %xmm3, %xmm5
mulsd %xmm2, %xmm0
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm5, %xmm2
mulsd %xmm1, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
divsd %xmm4, %xmm0
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
divpd %xmm4, %xmm1
movupd 0x430(%rdx), %xmm2
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulsd 0x440(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x80, %rsp
movq %rdi, %rbx
movsd 0x430(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x438(%rdx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x440(%rdx), %xmm0
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x18(%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 0x21cf2
movsd (%rsp), %xmm0
xorps 0x18b6c(%rip), %xmm0    # 0x3a6d0
leaq 0x78(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x21cf2
movsd 0x10(%rsp), %xmm0
xorps 0x18b42(%rip), %xmm0    # 0x3a6d0
leaq 0x70(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x68(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x21cf2
movq %rsp, %rsi
movq %rax, %rdi
callq 0x21cf2
movq %rsp, %rsi
movq %rax, %rdi
callq 0x21cf2
movsd 0x8(%rsp), %xmm0
xorps 0x18aee(%rip), %xmm0    # 0x3a6d0
leaq 0x60(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x58(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x21cf2
movsd 0x8(%rsp), %xmm0
xorps 0x18ab0(%rip), %xmm0    # 0x3a6d0
leaq 0x50(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
movsd (%rsp), %xmm0
xorps 0x18a94(%rip), %xmm0    # 0x3a6d0
leaq 0x48(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
movsd 0x10(%rsp), %xmm0
xorps 0x18a77(%rip), %xmm0    # 0x3a6d0
leaq 0x40(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x21cf2
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq $0x4, %rax
jne 0x21cd3
cmpq $0x4, 0x28(%rsp)
jne 0x21cd3
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
retq
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
jmp 0x21cb3
movq 0x30(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq $0x4, %rcx
jne 0x21cd3
cmpq $0x4, 0x28(%rsp)
jne 0x21cd3
movq %rax, %rdi
callq 0x55e0
leaq 0x18a36(%rip), %rdi     # 0x3a710
leaq 0x18acd(%rip), %rsi     # 0x3a7ae
leaq 0x1a0b0(%rip), %rcx     # 0x3bd98
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/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 0x188fb(%rip), %xmm0    # 0x3a6d0
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 0x1726a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1726a
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
cmpq $0x3, %rax
jne 0x21e44
cmpq $0x1, 0x18(%rsp)
jne 0x21e44
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x188c5(%rip), %rdi     # 0x3a710
leaq 0x1895c(%rip), %rsi     # 0x3a7ae
leaq 0x18b47(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
movq 0x20(%rsp), %rcx
addq 0x10(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x21e83
cmpq $0x1, 0x18(%rsp)
jne 0x21e83
movq %rax, %rdi
callq 0x55e0
callq 0x5a1e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22d14
fstp %st(0)
movq %rbx, %rdi
callq 0x22d42
fstp %st(0)
movq %rbx, %rdi
callq 0x22d70
fstp %st(0)
movq %rbx, %rdi
callq 0x22dd2
fstp %st(0)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26992(%rip), %al      # 0x49710
testb %al, %al
je 0x22dca
fldt (%rbx)
fldz
movl $0x1, %eax
leaq 0x2687e(%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 0x22d92
fstp %st(1)
addq $0x10, %rsp
popq %rbx
retq
callq 0x5c1c
jmp 0x22d82
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26a40(%rip), %al      # 0x49820
testb %al, %al
je 0x22e3c
fldt (%rbx)
fld %st(0)
fadds 0x194fa(%rip)           # 0x3c2e8
fldz
movl $0x1, %eax
leaq 0x26924(%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 0x22e00
fstp %st(3)
fstp %st(1)
fstp %st(1)
addq $0x10, %rsp
popq %rbx
retq
callq 0x5d00
jmp 0x22de4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e633
ucomisd 0x8(%rsp), %xmm0
jb 0x2e633
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2e633
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2565c
jmp 0x2e644
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2433c
movq %rbx, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e658
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3041a
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0xceff(%rip), %rsi      # 0x3d320
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 0x92e2
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5400
leaq 0x186a5(%rip), %rax     # 0x48b10
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xceef(%rip), %rsi      # 0x3d367
leaq 0xcf27(%rip), %rdx      # 0x3d3a6
movl $0x69, %ecx
callq 0x30e1a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5390
jmp 0x30499
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x304b0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5350
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30551
movb $0x1, 0x3ba(%rdi)
cmpb $0x0, 0x3bb(%rdi)
jne 0x30561
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 0x305b6
addq $0x10, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x305aa
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_O1/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 $0x38, %rsp
movsd %xmm1, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0x1(%rdi)
jne 0x3178d
movb $0x1, 0x1(%r14)
leaq 0x8(%r14), %r12
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movsd %xmm0, 0x8(%rsp)
callq *(%rax)
leaq 0x171a4(%rip), %rax     # 0x48950
addq $0x10, %rax
leaq 0x18(%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 0x8(%rsp), %xmm0
movq %rbx, %r8
movsd 0x10(%rsp), %xmm1
callq 0x317f2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31802
movb $0x1, 0xe8(%rdi)
subq $0x78, %rsp
leaq 0x78(%rdi), %rax
leaq 0x1713f(%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 0x31878
addq $0x78, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d5f9(%rip), %r13     # 0x36fd0
leaq 0x1a73b(%rip), %rsi     # 0x24119
movl $0x1f, %edx
movq %r13, %rdi
callq 0x64a0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x6450
movsbl %al, %esi
movq %r13, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x6300
shll $0xa, %r15d
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x197e0
movl %r12d, 0x40(%r13)
movl %r15d, 0x44(%r13)
movl %r14d, 0x18(%r13)
movl %ebp, 0x3c(%r13)
leaq 0x68(%rsp), %rdi
callq 0x22ee8
movq (%rbx), %rax
movl $0xa, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x15b88
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22ee8
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x22f54
movq %rax, %r14
movq 0x2d553(%rip), %rdi     # 0x36fd0
leaq 0x1a6b5(%rip), %rsi     # 0x24139
movl $0x14, %edx
callq 0x64a0
cvtsi2sd %r14, %xmm0
divsd 0x1a56d(%rip), %xmm0    # 0x24008
movq 0x2d52e(%rip), %rdi     # 0x36fd0
callq 0x6680
movq %rax, %r14
leaq 0x1a8ff(%rip), %rsi     # 0x243b0
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6450
movsbl %al, %esi
movq %r14, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x6300
testq %rbx, %rbx
je 0x9af7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x9afc
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x58(%rsp), %rdi
callq 0x22f6e
leaq 0x68(%rsp), %rdi
callq 0x22f6e
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b26
movq %rax, %rbx
jmp 0x9b38
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22f6e
leaq 0x68(%rsp), %rdi
callq 0x22f6e
movq %rbx, %rdi
callq 0x6720
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d46a(%rip), %r15     # 0x36fd0
leaq 0x1a5e1(%rip), %rsi     # 0x2414e
movl $0x1d, %edx
movq %r15, %rdi
callq 0x64a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6450
movsbl %al, %esi
movq %r15, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x6300
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x197e0
movl %r14d, 0x18(%r15)
testl %ebp, %ebp
setne 0x38(%r15)
leaq 0x68(%rsp), %rdi
callq 0x22ee8
movq (%rbx), %rax
movl $0xa, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x15edc
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22ee8
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x22f54
movq %rax, %r14
movq 0x2d3ce(%rip), %rdi     # 0x36fd0
leaq 0x1a563(%rip), %rsi     # 0x2416c
movl $0x12, %edx
callq 0x64a0
cvtsi2sd %r14, %xmm0
divsd 0x1a3e8(%rip), %xmm0    # 0x24008
movq 0x2d3a9(%rip), %rdi     # 0x36fd0
callq 0x6680
movq %rax, %r14
leaq 0x1a77a(%rip), %rsi     # 0x243b0
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6450
movsbl %al, %esi
movq %r14, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x6300
leaq 0x58(%rsp), %rdi
callq 0x22f6e
leaq 0x68(%rsp), %rdi
callq 0x22f6e
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9c91
movq %rax, %rbx
jmp 0x9ca3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x22f6e
leaq 0x68(%rsp), %rdi
callq 0x22f6e
movq %rbx, %rdi
callq 0x6720