LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::operator=(forrocket::DateTime const&)
forrocket::DateTime& forrocket::DateTime::operator=(const DateTime& from) {
    if (this != &from) {
        year = from.year;
        month = from.month;
        day = from.day;
        hour = from.hour;
        min = from.min;
        sec = from.sec;
        msec = from.msec;
    }
    return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x173c0
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rsi), %ecx
movl %ecx, 0x18(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::operator+(double)
forrocket::DateTime forrocket::DateTime::operator+(const double sec_double) {
    DateTime new_datetime = *this;
    unsigned int sec_int = static_cast<unsigned int>(sec_double);

    unsigned int ms = static_cast<unsigned int>((sec_double - sec_int) * 1000.0);
    new_datetime.msec += ms;
    if (new_datetime.msec >= 1000) {
        new_datetime.sec += 1;
        new_datetime.msec -= 1000;
    }

    new_datetime.sec += sec_int;
    if (new_datetime.sec >= 60) {
        unsigned int m = static_cast<unsigned int>(new_datetime.sec / 60);
        new_datetime.min += m;
        new_datetime.sec -= m * 60;
    }

    if (new_datetime.min >= 60) {
        unsigned int h = static_cast<unsigned int>(new_datetime.min / 60);
        new_datetime.hour += h;
        new_datetime.min -= h * 60;
    }

    if (new_datetime.hour >= 24) {
        unsigned int d = static_cast<unsigned int>(new_datetime.hour / 24);
        new_datetime.day += d;
        new_datetime.hour -= d * 24;
    }

    // TODO:Month update
    return new_datetime;
}

// Assembly:
movq %rdi, %rax
movdqu (%rsi), %xmm1
movdqu %xmm1, (%rdi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
movl 0x14(%rsi), %edx
cvttsd2si %xmm0, %rdi
movl %edi, %r8d
cvtsi2sd %r8, %xmm2
subsd %xmm2, %xmm0
mulsd 0x23711(%rip), %xmm0    # 0x3ab00
cvttsd2si %xmm0, %r8
movl 0x18(%rsi), %esi
leal (%rsi,%r8), %r9d
cmpl $0x3e8, %r9d            # imm = 0x3E8
leal -0x3e8(%rsi,%r8), %esi
cmovbl %r9d, %esi
sbbl $-0x1, %edx
movl %esi, 0x18(%rax)
addl %edi, %edx
movl %edx, 0x14(%rax)
cmpl $0x3c, %edx
jb 0x1743a
movl %edx, %esi
movl $0x88888889, %edi       # imm = 0x88888889
imulq %rsi, %rdi
shrq $0x25, %rdi
addl %edi, %ecx
movl %ecx, 0x10(%rax)
imull $-0x3c, %edi, %esi
addl %edx, %esi
movl %esi, 0x14(%rax)
pshufd $0xff, %xmm1, %xmm0     # xmm0 = xmm1[3,3,3,3]
movd %xmm0, %edx
cmpl $0x3c, %ecx
jb 0x17464
movl %ecx, %esi
movl $0x88888889, %edi       # imm = 0x88888889
imulq %rsi, %rdi
shrq $0x25, %rdi
addl %edi, %edx
movl %edx, 0xc(%rax)
imull $-0x3c, %edi, %esi
addl %ecx, %esi
movl %esi, 0x10(%rax)
cmpl $0x18, %edx
jb 0x17491
movl %edx, %ecx
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
imulq %rcx, %rsi
shrq $0x24, %rsi
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
movd %xmm0, %ecx
addl %esi, %ecx
movl %ecx, 0x8(%rax)
shll $0x3, %esi
leal (%rsi,%rsi,2), %ecx
subl %ecx, %edx
movl %edx, 0xc(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::UpdateJulianDate()
void forrocket::SequenceClock::UpdateJulianDate() {
    DateTime UTC_date = UTC_date_init + countup_time;
    julian_data = UTC2JulianDate(UTC_date);
    modified_julian_date = JulianDate2ModifiedJulianDate(julian_data);
    greenwich_sidereal_time = JulianDate2GreenwichSiderealTime(julian_data);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movsd 0x38(%rdi), %xmm0
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x173c2
movl (%r14), %ecx
movl 0x4(%r14), %edx
imull $0x16f, %ecx, %eax      # imm = 0x16F
leal 0x9(%rdx), %esi
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %rsi, %rdi
shrq $0x23, %rdi
addl %ecx, %edi
leal (,%rdi,8), %ecx
subl %edi, %ecx
shrl $0x2, %ecx
imull $0x113, %edx, %edx      # imm = 0x113
imulq $0x38e38e39, %rdx, %rdx # imm = 0x38E38E39
shrq $0x21, %rdx
addl 0x8(%r14), %eax
addl %edx, %eax
subl %ecx, %eax
cvtsi2sd %rax, %xmm1
addsd 0x2360b(%rip), %xmm1    # 0x3ab10
movl 0x14(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x235ff(%rip), %xmm2    # 0x3ab18
divsd %xmm2, %xmm0
movl 0x10(%r14), %eax
cvtsi2sd %rax, %xmm3
addsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movl 0xc(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addsd %xmm3, %xmm0
divsd 0x235da(%rip), %xmm0    # 0x3ab20
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x235d2(%rip), %xmm1    # 0x3ab28
addsd %xmm0, %xmm1
addsd 0x235ce(%rip), %xmm0    # 0x3ab30
movsd %xmm1, 0x8(%rbx)
divsd 0x235c9(%rip), %xmm0    # 0x3ab38
movsd 0x235c9(%rip), %xmm1    # 0x3ab40
mulsd %xmm0, %xmm1
addsd 0x235c5(%rip), %xmm1    # 0x3ab48
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x235bd(%rip), %xmm2    # 0x3ab50
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x22cfc(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x235a7(%rip), %xmm0    # 0x3ab58
addsd (%rsp), %xmm0
mulsd 0x235a2(%rip), %xmm0    # 0x3ab60
movsd %xmm0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::UTC2JulianDate(forrocket::DateTime&)
double forrocket::SequenceClock::UTC2JulianDate(DateTime& UTC) {
    // return 367 * UTC.year - static_cast<int>(7 * (UTC.year + static_cast<int>((UTC.month + 9) / 12)) / 4) + static_cast<int>(275 * UTC.month / 9)
    //             + UTC.day + 1721013.5 + ((UTC.sec / 60.0 + UTC.min) / 60.0 + UTC.hour) / 24.0;
    return 367 * UTC.year - static_cast<int>(7 * (UTC.year + static_cast<int>((UTC.month + 9) / 12)) / 4) + static_cast<int>(275 * UTC.month / 9)
                + UTC.day + 1721013.5 + ((UTC.sec / 60.0 + UTC.min) / 60.0 + UTC.hour) / 24.0;
}

// Assembly:
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
imull $0x16f, %ecx, %eax      # imm = 0x16F
leal 0x9(%rdx), %edi
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
imulq %rdi, %r8
shrq $0x23, %r8
addl %ecx, %r8d
leal (,%r8,8), %ecx
subl %r8d, %ecx
shrl $0x2, %ecx
imull $0x113, %edx, %edx      # imm = 0x113
imulq $0x38e38e39, %rdx, %rdx # imm = 0x38E38E39
shrq $0x21, %rdx
addl 0x8(%rsi), %eax
addl %edx, %eax
subl %ecx, %eax
cvtsi2sd %rax, %xmm1
addsd 0x234f2(%rip), %xmm1    # 0x3ab10
movl 0x14(%rsi), %eax
cvtsi2sd %rax, %xmm0
movsd 0x234ea(%rip), %xmm2    # 0x3ab18
divsd %xmm2, %xmm0
movl 0x10(%rsi), %eax
cvtsi2sd %rax, %xmm3
addsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movl 0xc(%rsi), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addsd %xmm3, %xmm0
divsd 0x234c7(%rip), %xmm0    # 0x3ab20
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::JulianDate2GreenwichSiderealTime(double)
double forrocket::SequenceClock::JulianDate2GreenwichSiderealTime(const double julian) {
    double julian_century = (julian - 2451545.0) / 36525.0;
    double greenwich_sidereal = 67310.54841 + (876600.0 * 3600.0 + 8640184.812866) * julian_century + 0.093104 * std::pow(julian_century, 2) - 6.2e-6 * std::pow(julian_century, 3);
    // double green_sidereal_deg = greenwich_sidereal_time / 240.0;
    greenwich_sidereal = greenwich_sidereal * std::fmod((2.0 * 3.14159265) / 86400.0, (2.0 * 3.14159265));
    return greenwich_sidereal;
}

// Assembly:
pushq %rax
addsd 0x234bf(%rip), %xmm0    # 0x3ab30
divsd 0x234bf(%rip), %xmm0    # 0x3ab38
movsd 0x234bf(%rip), %xmm1    # 0x3ab40
mulsd %xmm0, %xmm1
addsd 0x234bb(%rip), %xmm1    # 0x3ab48
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x234b3(%rip), %xmm2    # 0x3ab50
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x22bf2(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x2349d(%rip), %xmm0    # 0x3ab58
addsd (%rsp), %xmm0
mulsd 0x23498(%rip), %xmm0    # 0x3ab60
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::SequenceClock(forrocket::DateTime)
forrocket::SequenceClock::SequenceClock(DateTime UTC_init) {
    UTC_date_init = UTC_init;
    countup_time = 0.0;
    countup_time_ref = 0.0;
    UpdateJulianDate();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x16e20
movq %r15, %rdi
movq %rbx, %rsi
callq 0x173a4
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17494
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::SequenceClock(forrocket::DateTime, double)
forrocket::SequenceClock::SequenceClock(DateTime UTC_init, double countup_time_init) {
    UTC_date_init = UTC_init;
    countup_time = 0.0;
    countup_time_ref = countup_time_init;
    UpdateJulianDate();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x16e20
movq %r15, %rdi
movq %rbx, %rsi
callq 0x173a4
movq $0x0, 0x38(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%r14)
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x17494
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/sequence_clock.cpp
// Function: forrocket::SequenceClock::ModifiedJulianDate2UTC(double)
forrocket::DateTime forrocket::SequenceClock::ModifiedJulianDate2UTC(const double modified_julian) {
    double a = static_cast<int>(modified_julian) + 2400001.0;
    double q = modified_julian - static_cast<int>(modified_julian);
    double b = static_cast<int>((a - 1867216.25) / 36524.25);
    double c = a + b - static_cast<int>(0.25 * b) + 1525;
    double d = static_cast<int>((c - 121.1) / 365.25);
    double e = static_cast<int>(365.25 * d);
    double f = static_cast<int>((c - e) / 50.6001);

    unsigned int day = c - e - static_cast<unsigned int>(30.6001 * f);
    unsigned int month = f - 1 - 12 * static_cast<unsigned int>(f / 14);
    unsigned int year = d - 4715 - static_cast<unsigned int>((7 + month) / 10);
    unsigned int hour = static_cast<unsigned int>(24 * q);
    unsigned int min = 60 * (24 * q - hour);
    unsigned int sec = 60 * (min) - static_cast<unsigned int>(min);
    return DateTime(year, month, day, hour, min, sec);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm2
subsd %xmm2, %xmm0
addsd 0x23339(%rip), %xmm2    # 0x3ab68
movsd 0x23339(%rip), %xmm1    # 0x3ab70
addsd %xmm2, %xmm1
divsd 0x23335(%rip), %xmm1    # 0x3ab78
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
addsd %xmm1, %xmm2
mulsd 0x23329(%rip), %xmm1    # 0x3ab80
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm2
addsd 0x2331d(%rip), %xmm2    # 0x3ab88
movsd 0x2331d(%rip), %xmm1    # 0x3ab90
addsd %xmm2, %xmm1
movsd 0x23319(%rip), %xmm3    # 0x3ab98
divsd %xmm3, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
mulsd %xmm1, %xmm3
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm2
movapd %xmm2, %xmm3
divsd 0x232f9(%rip), %xmm3    # 0x3aba0
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
movsd 0x232f1(%rip), %xmm4    # 0x3aba8
mulsd %xmm3, %xmm4
cvttsd2si %xmm4, %rax
movl %eax, %eax
xorps %xmm4, %xmm4
cvtsi2sd %rax, %xmm4
subsd %xmm4, %xmm2
cvttsd2si %xmm2, %rcx
movsd 0x232d5(%rip), %xmm2    # 0x3abb0
addsd %xmm3, %xmm2
divsd 0x232d1(%rip), %xmm3    # 0x3abb8
cvttsd2si %xmm3, %rax
shll $0x2, %eax
leal (%rax,%rax,2), %eax
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
subsd %xmm3, %xmm2
cvttsd2si %xmm2, %rdx
addsd 0x232b5(%rip), %xmm1    # 0x3abc0
leal 0x7(%rdx), %eax
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
imulq %rax, %rsi
shrq $0x23, %rsi
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rsi
mulsd 0x231ed(%rip), %xmm0    # 0x3ab20
cvttsd2si %xmm0, %r8
movl %r8d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
mulsd 0x231c9(%rip), %xmm0    # 0x3ab18
movq %rdi, %rbx
cvttsd2si %xmm0, %r9
imull $0x3b, %r9d, %eax
movl %eax, (%rsp)
callq 0x16e70
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/satmo1976.cpp
// Function: standardatmosphere1976::Atmosphere(double)
std::vector<double> standardatmosphere1976::Atmosphere(double geometric_altitude) {
    // input : geometric altitude [m]
    // output: density, pressure, temeratrue, sound speed
    std::vector<double> res;
    if (geometric_altitude > 86.0e3) {
        res = UpperAtmosphere(geometric_altitude/1e3);
    } else {
        res = LowerAtmosphere(geometric_altitude/1e3);
    }
    res.push_back(std::sqrt(res[2] / temp_sealevel) * soundspeed_sealevel);
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd 0x23244(%rip), %xmm0    # 0x3abc8
movupd %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
divsd 0x23168(%rip), %xmm0    # 0x3ab00
leaq 0x8(%rsp), %r15
movq %r15, %rdi
jbe 0x179a9
callq 0x17a44
jmp 0x179ae
callq 0x17cae
movq (%r15), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %r14
movq %r14, 0x8(%rbx)
movq 0x10(%r15), %r15
movq %r15, 0x10(%rbx)
movsd 0x10(%rax), %xmm0
divsd 0x319c7(%rip), %xmm0    # 0x49398
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x179e1
sqrtsd %xmm0, %xmm0
jmp 0x179e6
callq 0x52b0
mulsd 0x319c2(%rip), %xmm0    # 0x493b0
movsd %xmm0, 0x8(%rsp)
cmpq %r15, %r14
je 0x17a08
movsd %xmm0, (%r14)
addq $0x8, %r14
movq %r14, 0x8(%rbx)
jmp 0x17a18
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cde
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17a3c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/satmo1976.cpp
// Function: standardatmosphere1976::EvaluateCubic(double, double, double, double, double, double, double)
double standardatmosphere1976::EvaluateCubic(double a, double fa, double fpa, double b, double fb, double fpb, double u) {
    double d = (fb - fa) / (b - a);
    double t = (u - a) / (b - a);
    double p = 1.0 - t;
    double fu = p * fa + t * fb - p * t * (b - a) * (p * (d - fpa) - t * (d - fpb));
    return fu;
}

// Assembly:
movapd %xmm4, %xmm7
subsd %xmm1, %xmm7
subsd %xmm0, %xmm3
divsd %xmm3, %xmm7
subsd %xmm0, %xmm6
divsd %xmm3, %xmm6
movsd 0x228c4(%rip), %xmm0    # 0x3a720
subsd %xmm6, %xmm0
mulsd %xmm6, %xmm4
mulsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movapd %xmm7, %xmm4
subsd %xmm2, %xmm4
subsd %xmm5, %xmm7
mulsd %xmm6, %xmm7
mulsd %xmm0, %xmm4
subsd %xmm7, %xmm4
mulsd %xmm6, %xmm0
mulsd %xmm3, %xmm0
mulsd %xmm4, %xmm0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/satmo1976.cpp
// Function: standardatmosphere1976::KineticTemperature(double)
double standardatmosphere1976::KineticTemperature(double geometric_altitude) {
    double z = geometric_altitude;

    double C1 = -76.3232;
    double C2 = 19.9429;
    double C3 = 12.0;
    double C4 = 0.01875;
    double TC = 263.1905;
    double T7 = 186.8673;
    double Z8 = 91.0;
    double Z9 = 110.0;  
    double T9 = 240.0;
    double Z10 = 120.0;
    double T10 = 360.0;
    double T12 = 1000.0;

    double t;
    double xx, yy;

    if (z <= Z8) {
        t = T7;
    } else if (z < Z9) {
        xx = (z - Z8) / C2;
        yy = std::sqrt(1.0 - xx * xx);
        t = TC + C1 * yy;
    } else if (z < Z10) {
        t = T9 + C3 * (z - Z9);
    } else {
        xx = (earth_radius + Z10) / (earth_radius + z);
        yy = (T12 - T10) * std::exp(-C4 * (z - Z10) * xx);
        t = T12 - yy;
    }
    return t;
}

// Assembly:
pushq %rax
movsd 0x22d3e(%rip), %xmm1    # 0x3abe0
ucomisd %xmm0, %xmm1
jae 0x17ee9
movsd 0x22d38(%rip), %xmm1    # 0x3abe8
ucomisd %xmm0, %xmm1
jbe 0x17ef6
addsd 0x22d6a(%rip), %xmm0    # 0x3ac28
divsd 0x22d6a(%rip), %xmm0    # 0x3ac30
mulsd %xmm0, %xmm0
movsd 0x2284e(%rip), %xmm1    # 0x3a720
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x17f1e
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x17f27
movsd 0x22ce7(%rip), %xmm0    # 0x3abd8
jmp 0x17f7e
movsd 0x22cf2(%rip), %xmm1    # 0x3abf0
ucomisd %xmm0, %xmm1
jbe 0x17f39
addsd 0x22d04(%rip), %xmm0    # 0x3ac10
mulsd 0x22d04(%rip), %xmm0    # 0x3ac18
addsd 0x22d04(%rip), %xmm0    # 0x3ac20
jmp 0x17f7e
movapd %xmm1, %xmm0
callq 0x52b0
mulsd 0x22d09(%rip), %xmm0    # 0x3ac38
addsd 0x22d09(%rip), %xmm0    # 0x3ac40
jmp 0x17f7e
movsd 0x3142f(%rip), %xmm1    # 0x49370
movsd 0x22ca7(%rip), %xmm2    # 0x3abf0
addsd %xmm1, %xmm2
addsd %xmm0, %xmm1
addsd 0x22c9f(%rip), %xmm0    # 0x3abf8
divsd %xmm1, %xmm2
mulsd 0x22c9b(%rip), %xmm0    # 0x3ac00
mulsd %xmm2, %xmm0
callq 0x55f0
mulsd 0x22c92(%rip), %xmm0    # 0x3ac08
addsd 0x22b82(%rip), %xmm0    # 0x3ab00
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/wind.cpp
// Function: forrocket::EnvironmentWind::EnvironmentWind(bool)
forrocket::EnvironmentWind::EnvironmentWind(bool enable) {
    // enable=false => disableの時にしか呼ばない
    // TODO: 分かりづらいのでなんか良い方法考える
    wind_from_east = InterpolateParameter(0.0);
    wind_from_north = InterpolateParameter(0.0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
callq 0x19348
leaq 0xa0(%rbx), %r14
movq %r14, %rdi
callq 0x19348
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x1937e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x196d2
movq 0x80(%rsp), %rdi
callq 0x53d0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x180f5
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1810c
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x18123
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1813a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x1937e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x196d2
movq 0x80(%rsp), %rdi
callq 0x53d0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x18174
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1818b
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x181a2
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x181b9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x181ca
jmp 0x181d7
movq %rax, %r15
movq %rsp, %rdi
callq 0x18702
jmp 0x181da
movq %rax, %r15
movq %r14, %rdi
callq 0x18702
jmp 0x181e7
movq %rax, %r15
movq %rbx, %rdi
callq 0x18702
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
leaq 0x50(%rdi), %r15
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
movq $0x0, 0x90(%rdi)
movb (%rsi), %cl
movb %cl, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
cmpb $0x1, %cl
jne 0x19656
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x133aa
jmp 0x196ab
movq %rdi, %r12
testb %al, %al
je 0x1969e
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x13ea0
leaq 0x68(%r12), %rdi
leaq 0x68(%r14), %rsi
callq 0x13ea0
movl $0x80, %esi
leaq (%r12,%rsi), %rdi
addq %r14, %rsi
leaq 0x7(%rsp), %rdx
callq 0x197dd
movl 0x98(%r14), %eax
movl %eax, 0x98(%r12)
jmp 0x196ab
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x197a4
movq %rbx, %rdi
callq 0x19774
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x19750
movq %rsi, %r14
movb (%rsi), %cl
movb %cl, (%rbx)
movb 0x1(%rsi), %al
movb %al, 0x1(%rbx)
cmpb $0x1, %cl
jne 0x19702
addq $0x10, %r14
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x133aa
jmp 0x19750
testb %al, %al
je 0x19745
leaq 0x50(%r14), %rsi
leaq 0x50(%rbx), %rdi
callq 0x13ea0
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
callq 0x13ea0
movl $0x80, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
leaq 0x7(%rsp), %rdx
callq 0x197dd
movl 0x98(%r14), %eax
movl %eax, 0x98(%rbx)
jmp 0x19750
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/rocket/parameter/moment.cpp
// Function: forrocket::Moment::Moment()
forrocket::Moment::Moment() {
    gyro << 0.0, 0.0, 0.0;
    thrust << 0.0, 0.0, 0.0;
    aero_force << 0.0, 0.0, 0.0;
    aero_dumping << 0.0, 0.0, 0.0;
    jet_dumping << 0.0, 0.0, 0.0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %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 0x28(%rsp), %rsi
movq %rax, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
leaq 0x18(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
leaq 0x30(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
leaq 0x48(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
addq $0x60, %rbx
movq %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 0x28(%rsp), %rsi
movq %rax, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
addq $0x30, %rsp
popq %rbx
retq
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
jmp 0x19be5
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x19c05
cmpq $0x1, 0x10(%rsp)
jne 0x19c05
movq %rax, %rdi
callq 0x55e0
leaq 0x20b3c(%rip), %rdi     # 0x3a748
leaq 0x20bd3(%rip), %rsi     # 0x3a7e6
leaq 0x20dbe(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x34(%rsp), %r12
movq %r12, %rdi
callq 0x1738e
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x17714
leaq 0x138(%rsp), %r12
movq %r12, %rdi
callq 0x150d4
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
movups 0x30(%rbx), %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x40(%rbx), %rax
movq %rax, 0x10(%rdx)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x164b8
leaq 0x18(%rbx), %r13
movaps (%r14), %xmm0
movups %xmm0, 0x18(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x28(%rbx)
movsd 0x38(%r15), %xmm0
movq %r12, %rdi
callq 0x15e12
leaq 0x328(%rsp), %rax
movupd 0x18(%rbx), %xmm0
movupd 0x20(%rbx), %xmm4
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rax), %xmm1
mulpd %xmm0, %xmm1
movupd 0x18(%rax), %xmm0
movupd 0x30(%rax), %xmm2
movapd %xmm4, %xmm3
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm0, %xmm3
addpd %xmm1, %xmm3
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
movapd %xmm4, (%rsp)
leaq 0x338(%rsp), %rcx
movq %rcx, (%r14)
movq %rax, 0x10(%r14)
movq $0x2, 0x18(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
movq $0x1, 0x28(%r14)
movq %r13, 0x30(%r14)
movq %r13, 0x40(%r14)
movq %rax, 0x48(%r14)
movq $0x3, 0x58(%r14)
leaq 0xb8(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x1a0a4
movq 0x10(%r14), %rax
movq 0x20(%r14), %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
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movsd %xmm2, 0x10(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/rocket/parameter/velocity.cpp
// Function: forrocket::Velocity::Velocity()
forrocket::Velocity::Velocity() {
    ECI << 0.0, 0.0, 0.0;
    ECEF << 0.0, 0.0, 0.0;
    NED << 0.0, 0.0, 0.0;
    air_body << 0.0, 0.0, 0.0;
    mach_number = 0.0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq %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 0x28(%rsp), %rsi
movq %rax, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a2d3
cmpq $0x1, 0x10(%rsp)
jne 0x1a2d3
leaq 0x18(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a2d3
cmpq $0x1, 0x10(%rsp)
jne 0x1a2d3
leaq 0x30(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a2d3
cmpq $0x1, 0x10(%rsp)
jne 0x1a2d3
leaq 0x48(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, (%rax)
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x16d64
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a2d3
cmpq $0x1, 0x10(%rsp)
jne 0x1a2d3
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1a2b3
jmp 0x1a2b3
jmp 0x1a2b3
jmp 0x1a2b3
jmp 0x1a2b3
jmp 0x1a2b3
jmp 0x1a2b3
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x1a2d3
cmpq $0x1, 0x10(%rsp)
jne 0x1a2d3
movq %rax, %rdi
callq 0x55e0
leaq 0x2046e(%rip), %rdi     # 0x3a748
leaq 0x20505(%rip), %rsi     # 0x3a7e6
leaq 0x206f0(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%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 0x19348
leaq 0xf8(%rbx), %r15
movq %r15, %rdi
callq 0x19348
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x41(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1937e
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x196d2
movq 0xa0(%rsp), %rdi
callq 0x53d0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa6d
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa87
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa9e
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1aab5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
leaq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x1937e
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x196d2
movq 0xa0(%rsp), %rdi
callq 0x53d0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1aafc
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab16
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab2d
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab44
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ab65
jmp 0x1ab74
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x18702
jmp 0x1ab77
movq %rax, %rbx
movq %r15, %rdi
callq 0x18702
jmp 0x1ab84
movq %rax, %rbx
movq %r14, %rdi
callq 0x18702
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19348
leaq 0xf8(%rbx), %r15
movq %r15, %rdi
callq 0x19348
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x41(%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 0x1937e
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x196d2
movq 0xb0(%rsp), %rdi
callq 0x53d0
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1ac6d
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1ac8a
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1aca1
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1acb8
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
leaq 0x30(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x1937e
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x196d2
movq 0xb0(%rsp), %rdi
callq 0x53d0
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1acff
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad1c
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad33
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad4a
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 0x1ad81
jmp 0x1ad90
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x18702
jmp 0x1ad93
movq %rax, %rbx
movq %r15, %rdi
callq 0x18702
jmp 0x1ada0
movq %rax, %rbx
movq %r14, %rdi
callq 0x18702
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/rocket/engine.cpp
// Function: forrocket::Engine::Update(double, double, double)
void forrocket::Engine::Update(const double t, const double pressure, const double mass_prop) {
    if (t <= burn_duration && mass_prop > 0.0) {
        Ignittion();
    } else {
        Cutoff();
    }

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

    gimbal_angle_y_axis = mis_alignment_angle_y_axis;
    gimbal_angle_z_axis = mis_alignment_angle_z_axis;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm4
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
movapd %xmm4, %xmm5
cmplepd %xmm0, %xmm5
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
cmpltpd %xmm2, %xmm3
andpd %xmm5, %xmm3
movd %xmm3, %eax
andb $0x1, %al
movb %al, (%rdi)
je 0x1b79e
leaq 0x58(%rbx), %rdi
movapd %xmm4, %xmm0
movapd %xmm4, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x1975c
movsd 0x8(%rsp), %xmm1
mulsd 0x38(%rbx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
leaq 0xf8(%rbx), %rdi
movapd 0x10(%rsp), %xmm0
callq 0x1975c
jmp 0x1b7a6
movq $0x0, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e38c
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x1e428
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x108(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x1e45a
leaq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x150(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x168(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x180(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x198(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x1b0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e522
leaq 0x1c8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e618
leaq 0x1e0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x1f8(%rbx), %rdi
movq %r14, %rsi
callq 0x1e72c
leaq 0x210(%rbx), %rdi
movq %r14, %rsi
callq 0x1e812
leaq 0x228(%rbx), %rdi
movq %r14, %rsi
callq 0x1e908
leaq 0x240(%rbx), %rdi
movq %r14, %rsi
callq 0x1e9d6
leaq 0x258(%rbx), %rdi
movq %r14, %rsi
callq 0x1ea86
leaq 0x270(%rbx), %rdi
movq %r14, %rsi
callq 0x1ea86
leaq 0x288(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
leaq 0x2a0(%rbx), %rdi
movq %r14, %rsi
callq 0x1e38c
addq $0x2b8, %rbx            # imm = 0x2B8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eb4a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1975c
movapd 0x19e78(%rip), %xmm1    # 0x3a710
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x280(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1975c
movapd 0x19e4a(%rip), %xmm1    # 0x3a710
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x288(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1975c
movapd 0x19e1c(%rip), %xmm1    # 0x3a710
xorpd %xmm0, %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, 0x290(%rbx)
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b728
cmpb $0x1, 0x48(%r14)
jne 0x209d3
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 0x19d82(%rip), %xmm0    # 0x3a710
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 0x20a2c
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
mulpd 0x10(%rsp), %xmm2
movapd %xmm2, (%rbx)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
jmp 0x20a4a
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 0x16d64
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16d64
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x20a77
cmpq $0x1, 0x20(%rsp)
je 0x20a4a
jmp 0x20a77
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 0x20a57
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x20a77
cmpq $0x1, 0x20(%rsp)
jne 0x20a77
movq %rax, %rdi
callq 0x55e0
leaq 0x19cca(%rip), %rdi     # 0x3a748
leaq 0x19d61(%rip), %rsi     # 0x3a7e6
leaq 0x19f4c(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20c1a
movsd 0x38(%r14), %xmm0
leaq 0x4f0(%r14), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1975c
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 0x16ca8
leaq 0x60(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16ca8
leaq 0x58(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16ca8
movq %rax, %r15
leaq 0x590(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1975c
leaq 0x50(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x16ca8
leaq 0x48(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16ca8
leaq 0x40(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16ca8
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x16ca8
movq %rax, %r15
leaq 0x630(%r14), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1975c
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x16ca8
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x20c6d
cmpq $0x3, 0x20(%rsp)
jne 0x20c6d
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 0x20c4d
jmp 0x20c4d
jmp 0x20c4d
jmp 0x20c4d
jmp 0x20c4d
jmp 0x20c4d
jmp 0x20c4d
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x20c6d
cmpq $0x3, 0x20(%rsp)
jne 0x20c6d
movq %rax, %rdi
callq 0x55e0
leaq 0x19ad4(%rip), %rdi     # 0x3a748
leaq 0x19b6b(%rip), %rsi     # 0x3a7e6
leaq 0x19b8c(%rip), %rcx     # 0x3a80e
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1975c
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 0x1975c
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x16d64
movq %rax, %r15
addq $0x810, %r14            # imm = 0x810
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1975c
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x16d64
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x20d68
cmpq $0x1, 0x20(%rsp)
jne 0x20d68
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x20d48
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x20d68
cmpq $0x1, 0x20(%rsp)
jne 0x20d68
movq %rax, %rdi
callq 0x55e0
leaq 0x199d9(%rip), %rdi     # 0x3a748
leaq 0x19a70(%rip), %rsi     # 0x3a7e6
leaq 0x19c5b(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
nop