LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sus304[P]ForRocket/src/rocket/parameter/interpolate_parameter.cpp
// Function: forrocket::InterpolateParameter::InterpolateParameter(forrocket::InterpolateParameter const&)
forrocket::InterpolateParameter::InterpolateParameter(const InterpolateParameter& from) {
    enable_1dlog = from.enable_1dlog;
    enable_2dlog = from.enable_2dlog;

    if (from.enable_1dlog) polator_1d = from.polator_1d;
    else if (from.enable_2dlog) polator_2d = from.polator_2d;
    else {
        value_const = from.value_const;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3c0e0
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3c110
jmp 0x3bf18
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movb 0x1(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x3bf7b
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x26540
jmp 0x3bf54
jmp 0x3bfb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3bfb8
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x365e0
jmp 0x3bfb8
movq -0x10(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x3bf9e
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rdi
callq 0x3c180
jmp 0x3bf9c
jmp 0x3bfb0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x3bfb2
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x36620
movq -0x18(%rbp), %rdi
callq 0x6760
nopw (%rax,%rax)
// File: sus304[P]ForRocket/src/rocket/parameter/interpolate_parameter.cpp
// Function: forrocket::InterpolateParameter::operator=(forrocket::InterpolateParameter const&)
forrocket::InterpolateParameter& forrocket::InterpolateParameter::operator=(const InterpolateParameter& from) {
    if (this != &from) {
        enable_1dlog = from.enable_1dlog;
        enable_2dlog = from.enable_2dlog;

        if (from.enable_1dlog) polator_1d = from.polator_1d;
        else if (from.enable_2dlog) polator_2d = from.polator_2d;
        else {
            value_const = from.value_const;
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x3c061
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movb 0x1(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x3c02a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x26540
jmp 0x3c05f
movq -0x10(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x3c04b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rdi
callq 0x3c180
jmp 0x3c05d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x3c05f
jmp 0x3c061
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sus304[P]ForRocket/src/rocket/parameter/position.cpp
// Function: forrocket::Position::Initialize(forrocket::DateTime, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&)
void forrocket::Position::Initialize(const DateTime datetime, const Eigen::Vector3d& LLH) {
    SequenceClock clock(datetime);
    Coordinate coordinate;
    this->LLH = LLH;
    ECEF = coordinate.LLH2ECEF(this->LLH);
    coordinate.setECI2ECEF(clock.countup_time);
    ECI = coordinate.dcm.ECEF2ECI * ECEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x390(%rbp)
leaq -0x7c(%rbp), %rdi
callq 0x33f00
leaq -0x60(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x34580
leaq -0x348(%rbp), %rdi
callq 0x2c800
movq -0x390(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rdi
callq 0x37a90
movq -0x390(%rbp), %rsi
addq $0x30, %rsi
leaq -0x378(%rbp), %rdi
callq 0x2f760
leaq -0x360(%rbp), %rdi
leaq -0x348(%rbp), %rsi
leaq -0x378(%rbp), %rdx
callq 0x2dc30
movq -0x390(%rbp), %rdi
addq $0x18, %rdi
leaq -0x360(%rbp), %rsi
callq 0x37c30
movsd -0x28(%rbp), %xmm0
leaq -0x348(%rbp), %rdi
callq 0x2d3e0
movq -0x390(%rbp), %rsi
leaq -0x348(%rbp), %rdi
addq $0x40, %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
addq $0x18, %rsi
callq 0x3e710
movq -0x390(%rbp), %rdi
movq %rax, -0x388(%rbp)
movq %rdx, -0x380(%rbp)
leaq -0x388(%rbp), %rsi
callq 0x3e760
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
nopl (%rax)
// File: sus304[P]ForRocket/src/rocket/parameter/velocity.cpp
// Function: forrocket::Velocity::Initialize(forrocket::DateTime, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&)
void forrocket::Velocity::Initialize(const DateTime datetime, const Eigen::Vector3d& NED, const Eigen::Vector3d& pos_LLH, const Eigen::Vector3d& pos_ECI) {
    SequenceClock clock(datetime);
    Coordinate coordinate;
    this->NED = NED;
    coordinate.setECEF2NED(pos_LLH);
    this->ECEF = coordinate.dcm.NED2ECEF * this->NED;
    coordinate.setECI2ECEF(clock.countup_time);
    this->ECI = coordinate.dcm.ECEF2ECI * this->ECEF + coordinate.dcm.EarthRotate * pos_ECI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp            # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3d0(%rbp)
leaq -0x8c(%rbp), %rdi
callq 0x33f00
leaq -0x70(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
callq 0x34580
leaq -0x358(%rbp), %rdi
callq 0x2c800
movq -0x3d0(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rdi
callq 0x37a90
movq -0x20(%rbp), %rsi
leaq -0x370(%rbp), %rdi
callq 0x2f760
leaq -0x358(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x2d5e0
movq -0x3d0(%rbp), %rsi
leaq -0x358(%rbp), %rdi
addq $0x40, %rdi
addq $0x168, %rdi            # imm = 0x168
addq $0x30, %rsi
callq 0x3e710
movq -0x3d0(%rbp), %rdi
movq %rax, -0x380(%rbp)
movq %rdx, -0x378(%rbp)
addq $0x18, %rdi
leaq -0x380(%rbp), %rsi
callq 0x3e760
movsd -0x38(%rbp), %xmm0
leaq -0x358(%rbp), %rdi
callq 0x2d3e0
movq -0x3d0(%rbp), %rsi
leaq -0x358(%rbp), %rdi
addq $0x40, %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
addq $0x18, %rsi
callq 0x3e710
movq %rax, -0x3b8(%rbp)
movq %rdx, -0x3b0(%rbp)
leaq -0x358(%rbp), %rdi
addq $0x40, %rdi
addq $0x240, %rdi            # imm = 0x240
movq -0x28(%rbp), %rsi
callq 0x3e710
movq %rax, -0x3c8(%rbp)
movq %rdx, -0x3c0(%rbp)
leaq -0x3a8(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
leaq -0x3c8(%rbp), %rdx
callq 0x41950
movq -0x3d0(%rbp), %rdi
leaq -0x3a8(%rbp), %rsi
callq 0x419c0
addq $0x3d0, %rsp            # imm = 0x3D0
popq %rbp
retq
// File: sus304[P]ForRocket/src/rocket/engine.cpp
// Function: forrocket::Engine::Reset()
void forrocket::Engine::Reset() {
    burning = false;

    thrust = 0.0;
    mdot_prop = 0.0;
    gimbal_angle_y_axis = 0.0;
    gimbal_angle_z_axis = 0.0;
    mis_alignment_angle_y_axis = 0.0;
    mis_alignment_angle_z_axis = 0.0;

    enable_gimbal = false;

    area_exit = 0.0;
    burn_duration = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
movb $0x0, 0x50(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/rocket/engine.cpp
// Function: forrocket::Engine::Engine(double, double, double, double)
forrocket::Engine::Engine(const double burn_duration, const double thrust_const, const double mdot_prop_const, const double area_exit) {
    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);

    getTotalImpulse(thrust_const, burn_duration);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x188(%rbp)
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movb $0x0, 0x50(%rdi)
addq $0x58, %rdi
movq %rdi, -0x190(%rbp)
callq 0x3bb50
movq -0x188(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x180(%rbp)
callq 0x3bb50
jmp 0x43239
movq -0x188(%rbp), %rdi
callq 0x43050
movq -0x188(%rbp), %rax
movb $0x0, 0x50(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
leaq -0xd8(%rbp), %rdi
callq 0x3bbc0
jmp 0x43277
movq -0x188(%rbp), %rdi
addq $0x58, %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3bfd0
jmp 0x43290
leaq -0xd8(%rbp), %rdi
callq 0x365b0
movsd -0x20(%rbp), %xmm0
leaq -0x178(%rbp), %rdi
callq 0x3bbc0
jmp 0x432af
movq -0x188(%rbp), %rdi
addq $0xf8, %rdi
leaq -0x178(%rbp), %rsi
callq 0x3bfd0
jmp 0x432cb
leaq -0x178(%rbp), %rdi
callq 0x365b0
movq -0x188(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x430b0
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x43350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x43344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x365b0
jmp 0x43344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x365b0
movq -0x180(%rbp), %rdi
callq 0x365b0
movq -0x190(%rbp), %rdi
callq 0x365b0
movq -0x30(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x198(%rbp)
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movb $0x0, 0x50(%rdi)
addq $0x58, %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x3bb50
movq -0x198(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x190(%rbp)
callq 0x3bb50
jmp 0x43423
movq -0x198(%rbp), %rdi
callq 0x43050
movq -0x198(%rbp), %rax
movb $0x0, 0x50(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
leaq -0xe8(%rbp), %rdi
callq 0x3bbc0
jmp 0x43461
movq -0x198(%rbp), %rdi
addq $0x58, %rdi
leaq -0xe8(%rbp), %rsi
callq 0x3bfd0
jmp 0x4347a
leaq -0xe8(%rbp), %rdi
callq 0x365b0
movsd -0x20(%rbp), %xmm0
leaq -0x188(%rbp), %rdi
callq 0x3bbc0
jmp 0x43499
movq -0x198(%rbp), %rdi
addq $0xf8, %rdi
leaq -0x188(%rbp), %rsi
callq 0x3bfd0
jmp 0x434b5
leaq -0x188(%rbp), %rdi
callq 0x365b0
movq -0x198(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x40(%rdi)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x430b0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4354e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x43542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x365b0
jmp 0x43542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x365b0
movq -0x190(%rbp), %rdi
callq 0x365b0
movq -0x1a0(%rbp), %rdi
callq 0x365b0
movq -0x40(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x43e7c
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43e7c
movq -0x28(%rbp), %rdi
callq 0x43f30
jmp 0x43e85
movq -0x28(%rbp), %rdi
callq 0x43f50
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x43ef1
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x38(%rdi), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0xf8, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x43f05
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x28(%rbp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/./src/environment/gravity.hpp
// Function: forrocket::gravity(double)
inline double gravity(const double altitude) {
        WGS84 wgs84;
        double geocentric_height;
        if (altitude < 0.0) geocentric_height = wgs84.a;
        else geocentric_height = altitude + wgs84.a;
        return wgs84.GM / std::pow(geocentric_height, 2);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2ee40
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x4a4cc
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x4a4db
movsd -0x8(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
movl $0x2, %edi
callq 0x283f0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/rocket/rocket.cpp
// Function: forrocket::Rocket::getCA(double)
double forrocket::Rocket::getCA(const double mach_number) {
    if (engine.burning) {
        this->CA = CA_src(mach_number);
    } else {
        this->CA = CA_burnout_src(mach_number);
    }
    return this->CA;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x48(%rax)
je 0x51e32
movq -0x18(%rbp), %rdi
addq $0x9f0, %rdi            # imm = 0x9F0
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x18(%rbp), %rax
movsd %xmm0, 0x268(%rax)
jmp 0x51e53
movq -0x18(%rbp), %rdi
addq $0xa90, %rdi            # imm = 0xA90
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x18(%rbp), %rax
movsd %xmm0, 0x268(%rax)
movq -0x18(%rbp), %rax
movsd 0x268(%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xc70, %rdi            # imm = 0xC70
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x18(%rbp), %rax
movsd %xmm0, 0x280(%rax)
movsd 0x280(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x51f73
movq -0x18(%rbp), %rax
movsd 0x4516d(%rip), %xmm0    # 0x970d0
mulsd 0x280(%rax), %xmm0
movsd %xmm0, 0x280(%rax)
movq -0x18(%rbp), %rax
movsd 0x280(%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xd10, %rdi            # imm = 0xD10
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x18(%rbp), %rax
movsd %xmm0, 0x288(%rax)
movsd 0x288(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x51ff3
movq -0x18(%rbp), %rax
movsd 0x450ed(%rip), %xmm0    # 0x970d0
mulsd 0x288(%rax), %xmm0
movsd %xmm0, 0x288(%rax)
movq -0x18(%rbp), %rax
movsd 0x288(%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xdb0, %rdi            # imm = 0xDB0
movsd -0x10(%rbp), %xmm0
callq 0x3c070
movq -0x18(%rbp), %rax
movsd %xmm0, 0x290(%rax)
movsd 0x290(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x52073
movq -0x18(%rbp), %rax
movsd 0x4506d(%rip), %xmm0    # 0x970d0
mulsd 0x290(%rax), %xmm0
movsd %xmm0, 0x290(%rax)
movq -0x18(%rbp), %rax
movsd 0x290(%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq %rax, %rdi
addq $0x48, %rdi
movsd 0x38(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x218(%rax), %xmm2
callq 0x43e30
movq -0xf0(%rbp), %rdi
callq 0x2f9d0
movq -0xe8(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x521fa
movq -0xe8(%rbp), %rax
movsd 0x70(%rax), %xmm0
callq 0x67f0
movq -0xe8(%rbp), %rax
movsd %xmm0, -0x108(%rbp)
movsd 0x70(%rax), %xmm0
callq 0x67f0
movq -0xe8(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x108(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x78(%rax), %xmm0
callq 0x6120
movq -0xe8(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movsd 0x70(%rax), %xmm0
callq 0x6120
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x2f6d0
movq -0xe8(%rbp), %rax
addq $0x48, %rax
addq $0x10, %rax
movq %rax, -0x100(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52a30
movq -0x100(%rbp), %rsi
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x52990
movq -0xf0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x52950
leaq -0x68(%rbp), %rdi
callq 0x2fba0
jmp 0x5229b
movq -0xf0(%rbp), %rsi
movq $0x0, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0xc0(%rbp), %rdx
callq 0x2f9f0
movq -0x118(%rbp), %rdi
movq $0x0, -0xc8(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0x2fa30
movq %rax, -0x110(%rbp)
jmp 0x5224d
movq -0x110(%rbp), %rdi
movq $0x0, -0xe0(%rbp)
leaq -0xe0(%rbp), %rsi
callq 0x2fa30
jmp 0x5226d
leaq -0xb8(%rbp), %rdi
callq 0x2fba0
jmp 0x5229b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x2fba0
jmp 0x522ab
movq -0xf8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x6760
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
testb $0x1, 0x48(%rax)
je 0x5250f
leaq -0x58(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x2fbd0
movq -0xe0(%rbp), %rdi
movsd 0x38(%rdi), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x4f0, %rdi            # imm = 0x4F0
movsd -0x60(%rbp), %xmm0
callq 0x3c070
movq -0x108(%rbp), %rsi
movsd %xmm0, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x100(%rbp)
leaq -0x88(%rbp), %rdx
callq 0x2f2e0
movq -0x100(%rbp), %rdi
movq $0x0, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x2f320
movq %rax, -0xf8(%rbp)
jmp 0x52378
movq -0xf8(%rbp), %rdi
movq $0x0, -0xa8(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x2f320
movq %rax, -0x110(%rbp)
jmp 0x5239f
movq -0x110(%rbp), %rdi
movq $0x0, -0xb0(%rbp)
leaq -0xb0(%rbp), %rsi
callq 0x2f320
movq %rax, -0x118(%rbp)
jmp 0x523c6
movq -0xe0(%rbp), %rdi
addq $0x590, %rdi            # imm = 0x590
movsd -0x60(%rbp), %xmm0
callq 0x3c070
movsd %xmm0, -0x120(%rbp)
jmp 0x523e8
movq -0x118(%rbp), %rdi
movsd -0x120(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
leaq -0xb8(%rbp), %rsi
callq 0x2f320
movq %rax, -0x128(%rbp)
jmp 0x52414
movq -0x128(%rbp), %rdi
movq $0x0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rsi
callq 0x2f320
movq %rax, -0x130(%rbp)
jmp 0x5243b
movq -0x130(%rbp), %rdi
movq $0x0, -0xc8(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0x2f320
movq %rax, -0x138(%rbp)
jmp 0x52462
movq -0x138(%rbp), %rdi
movq $0x0, -0xd0(%rbp)
leaq -0xd0(%rbp), %rsi
callq 0x2f320
movq %rax, -0x140(%rbp)
jmp 0x52489
movq -0xe0(%rbp), %rdi
addq $0x630, %rdi            # imm = 0x630
movsd -0x60(%rbp), %xmm0
callq 0x3c070
movsd %xmm0, -0x148(%rbp)
jmp 0x524ab
movq -0x140(%rbp), %rdi
movsd -0x148(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x2f320
jmp 0x524d0
leaq -0x80(%rbp), %rdi
callq 0x2f490
movq -0xe0(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
leaq -0x58(%rbp), %rsi
callq 0x52a60
jmp 0x5250f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2f490
jmp 0x52539
movq -0xf0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x220, %rsi            # imm = 0x220
callq 0x4e550
movq -0xe8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x2f9d0
movq -0x70(%rbp), %rdi
movsd 0x38(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x6d0, %rdi            # imm = 0x6D0
movsd -0x18(%rbp), %xmm0
callq 0x3c070
movq -0x78(%rbp), %rsi
movsd %xmm0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2f9f0
movq -0x70(%rbp), %rdi
addq $0x770, %rdi            # imm = 0x770
movsd -0x18(%rbp), %xmm0
callq 0x3c070
movsd %xmm0, -0x68(%rbp)
jmp 0x525cc
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2fa30
movq %rax, -0x88(%rbp)
jmp 0x525ec
movq -0x70(%rbp), %rdi
addq $0x810, %rdi            # imm = 0x810
movsd -0x18(%rbp), %xmm0
callq 0x3c070
movsd %xmm0, -0x90(%rbp)
jmp 0x5260b
movq -0x88(%rbp), %rdi
movsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2fa30
jmp 0x5262a
leaq -0x38(%rbp), %rdi
callq 0x2fba0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2fba0
movq -0x50(%rbp), %rdi
callq 0x6760
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2f9d0
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rax
movsd 0x350(%rax), %xmm0
movsd 0x1f0(%rax), %xmm1
movsd 0x268(%rax), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x350(%rax), %xmm0
movsd 0x1f0(%rax), %xmm1
movsd 0x270(%rax), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x468(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x460(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movaps 0x404df(%rip), %xmm1    # 0x95670
movsd -0x20(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x60(%rbp), %rdx
callq 0x2f9f0
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fa30
movq %rax, -0x80(%rbp)
jmp 0x551c9
movq -0x80(%rbp), %rdi
movaps 0x4049c(%rip), %xmm1    # 0x95670
movsd -0x38(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x2fa30
jmp 0x551ed
leaq -0x58(%rbp), %rdi
callq 0x2fba0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2fba0
movq -0x68(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2f9d0
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x522c0
movq -0x18(%rbp), %rsi
addq $0x430, %rsi            # imm = 0x430
leaq -0xa0(%rbp), %rdi
callq 0x3e710
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x55a30
movq -0x18(%rbp), %rsi
addq $0x430, %rsi            # imm = 0x430
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x55a70
leaq -0x30(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x37c30
movsd 0x41e00(%rip), %xmm0    # 0x970d0
movsd %xmm0, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x55cc0
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x55d60
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2f9d0
movq -0x18(%rbp), %rax
movsd 0x200(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x1e0(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x2f6d0
movq -0x18(%rbp), %rsi
addq $0x388, %rsi            # imm = 0x388
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x55a70
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x37c30
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2f9d0
movq -0x18(%rbp), %rax
movsd 0x200(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x208(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x2f6d0
movq -0x18(%rbp), %rsi
addq $0x388, %rsi            # imm = 0x388
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x55a70
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x37c30
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x350(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x278(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x1f0(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x1f8(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x298(%rax), %xmm0
movsd 0x401ce(%rip), %xmm1    # 0x95668
mulsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x52b00
movsd -0x70(%rbp), %xmm0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movsd %xmm0, (%rcx)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2f9d0
movq -0x18(%rbp), %rsi
addq $0x280, %rsi            # imm = 0x280
movq -0x18(%rbp), %rdx
addq $0x288, %rdx            # imm = 0x288
movq -0x18(%rbp), %rcx
addq $0x290, %rcx            # imm = 0x290
leaq -0x30(%rbp), %rdi
callq 0x2f6d0
movq -0x18(%rbp), %rax
addq $0x350, %rax            # imm = 0x350
movq %rax, -0x268(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52a30
movq -0x268(%rbp), %rsi
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rdx
callq 0x52990
movq -0x18(%rbp), %rdx
addq $0x1f0, %rdx            # imm = 0x1F0
leaq -0x208(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x55da0
movq -0x18(%rbp), %rax
movsd 0x1f8(%rax), %xmm0
movl $0x2, %edi
callq 0x283f0
movsd %xmm0, -0x240(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x208(%rbp), %rsi
leaq -0x240(%rbp), %rdx
callq 0x55e50
movq -0x18(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
addq $0x48, %rdi
callq 0x55fb0
movaps %xmm0, %xmm1
movsd 0x42089(%rip), %xmm0    # 0x97660
mulsd %xmm1, %xmm0
movsd %xmm0, -0x248(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
leaq -0x248(%rbp), %rdx
callq 0x55f00
movq -0x18(%rbp), %rdi
addq $0x430, %rdi            # imm = 0x430
callq 0x52a30
movq %rax, -0x250(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0x158(%rbp), %rsi
leaq -0x250(%rbp), %rdx
callq 0x56010
movq -0x260(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x56080
movq -0x258(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2f9d0
movq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rax
movsd 0x350(%rax), %xmm0
movsd 0x1f0(%rax), %xmm1
movsd 0x268(%rax), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movaps 0x3bdf2(%rip), %xmm1    # 0x95670
movsd -0x20(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x58(%rbp), %rdx
callq 0x2f9f0
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2fa30
movq %rax, -0x70(%rbp)
jmp 0x598b0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fa30
jmp 0x598bf
leaq -0x50(%rbp), %rdi
callq 0x2fba0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fba0
movq -0x60(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
fld1
fstpt -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b1f0
fstp %st(0)
leaq -0x20(%rbp), %rdi
callq 0x5b630
fstp %st(0)
leaq -0x20(%rbp), %rdi
callq 0x5b990
fstp %st(0)
leaq -0x20(%rbp), %rdi
callq 0x5bd10
fstp %st(0)
callq 0x5c0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sus304[P]ForRocket/./lib/boost/multi_array/index_range.hpp
// Function: boost::detail::multi_array::index_range<long, unsigned long>::index_range()
index_range()
    {
      start_ = from_start();
      finish_ = to_end();
      stride_ = 1;
      degenerate_ = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x5c9a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x5c9b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x1, 0x10(%rax)
movb $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f9d0
movq -0x8(%rbp), %rdi
callq 0x69700
movsd %xmm0, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x697b0
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x697e0
movsd %xmm0, -0xb8(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x697b0
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x69890
movsd %xmm0, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x697b0
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x699b0
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x69940
leaq -0x70(%rbp), %rdi
callq 0x69a00
movsd %xmm0, -0x30(%rbp)
movsd 0x2bf6e(%rip), %xmm0    # 0x95638
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0xa8(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x69a40
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6ac50
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x6ad00
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6ad50
movq -0x8(%rbp), %rdi
callq 0x6ad90
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x30a30
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6ae40
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x30a30
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6aef0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x30a30
movsd -0x90(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6afa0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x30a30
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6b050
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x30a30
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6b100
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %edx
movq %rdx, %rsi
callq 0x30a30
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x1180(%rax)
je 0x7a6f2
movq -0x40(%rbp), %rax
movsd -0x10(%rbp), %xmm0
ucomisd 0x1188(%rax), %xmm0
jb 0x7a6f0
movq -0x40(%rbp), %rax
movsd -0x10(%rbp), %xmm1
movsd 0x1190(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7a6f0
movl $0x20, %edi
callq 0x6430
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6eb40
jmp 0x7a6c7
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7a728
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x20, %esi
callq 0x6440
jmp 0x7a748
jmp 0x7a6f2
movl $0x20, %edi
callq 0x6430
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x65820
jmp 0x7a71d
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x20, %esi
callq 0x6440
movq -0x30(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movl 0x4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
cmpl (%rcx), %eax
jl 0x7dc67
movq -0x120(%rbp), %rax
movl (%rax), %edx
leaq 0x2868b(%rip), %rsi     # 0xa6218
xorl %eax, %eax
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x60f0
leaq -0x101(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x6770
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0x100(%rbp), %rdi
callq 0xd1d0
jmp 0x7dbd1
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x80e60
jmp 0x7dbe6
leaq 0x28672(%rip), %rsi     # 0xa625f
leaq 0x286aa(%rip), %rdx     # 0xa629e
leaq -0xe0(%rbp), %rdi
movl $0x69, %ecx
callq 0x80d90
jmp 0x7dc07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x7dc59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x7dc4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x80ea0
leaq -0x100(%rbp), %rdi
callq 0x6898
leaq -0x101(%rbp), %rdi
callq 0x6490
jmp 0x7dc70
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x6760
nopl (%rax)
// File: sus304[P]ForRocket/./lib/boost/throw_exception.hpp
// Function: void boost::throw_exception<boost::exception_detail::error_info_injector<boost::numeric::odeint::step_adjustment_error>>(boost::exception_detail::error_info_injector<boost::numeric::odeint::step_adjustment_error> const&)
BOOST_NORETURN inline void throw_exception( E const & e )
{
    //All boost exceptions are required to derive from std::exception,
    //to ensure compatibility with BOOST_NO_EXCEPTIONS.
    throw_exception_assert_compatibility(e);

#ifndef BOOST_EXCEPTION_DISABLE
    throw exception_detail::enable_both( e );
#else
    throw e;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81070
movl $0x40, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
callq 0x81080
jmp 0x80ef4
movq -0x20(%rbp), %rdi
leaq 0x62b51(%rip), %rsi     # 0xe3a50
leaq 0x1ea(%rip), %rdx       # 0x810f0
callq 0x6730
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6350
movq -0x10(%rbp), %rdi
callq 0x6760
nopl (%rax)