LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::CubicSpline1D::polate(double const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, int const&)
double forrocket::interpolate::CubicSpline1D::polate(const double& x, const std::vector<double>& x_src, const std::vector<double>& y_src, const int& fill_value) {
    int index_target;
    if (x < x_src[0]) {  // 左外挿
        switch (fill_value) {
        case 0:  // zero
            return 0;
            break;
        
        case 1:  // same
            return y_src[0];
            break;

        case 2:  // extrapolate
            index_target = 0;
            break;
        }
    }
    else if (x >= x_src[0] && x <= x_src[x_src.size()-1]) {  // 内挿
        for (int i=0; i < x_src.size(); ++i) {
            if (x <= x_src[i]) {
                index_target = i - 1;
                break;
            }
        }
    }
    else if (x > x_src[x_src.size()-1]) {  // 右外挿
        switch (fill_value) {
        case 0:  // zero
            return 0;
            break;
        
        case 1:  // same
            return y_src[y_src.size()-1];
            break;

        case 2:  // extrapolate
            index_target = x_src.size() - 1;
            break;
        }
    }

    double h = x - x_src[index_target];
    return a_spline[index_target] + b_spline[index_target] * h + c_spline[index_target] * std::pow(h, 2) + d_spline[index_target] * std::pow(h, 3);
}

// Assembly:
subq $0x18, %rsp
movsd (%rsi), %xmm0
movq (%rdx), %rax
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13fc3
movl (%r8), %edx
testl %edx, %edx
je 0x14006
cmpl $0x1, %edx
jne 0x1404a
movq (%rcx), %rax
movsd (%rax), %xmm0
jmp 0x140ad
ucomisd %xmm1, %xmm0
jb 0x13fd8
movq 0x8(%rdx), %rsi
movsd -0x8(%rsi), %xmm1
ucomisd %xmm0, %xmm1
jae 0x1400f
movq 0x8(%rdx), %rdx
ucomisd -0x8(%rdx), %xmm0
jbe 0x1404a
movl (%r8), %esi
testl %esi, %esi
je 0x14006
cmpl $0x2, %esi
je 0x140b2
cmpl $0x1, %esi
jne 0x1404a
movq 0x8(%rcx), %rax
movsd -0x8(%rax), %xmm0
jmp 0x140ad
xorpd %xmm0, %xmm0
jmp 0x140ad
cmpq %rax, %rsi
je 0x1404a
subq %rax, %rsi
sarq $0x3, %rsi
cmpq $0x1, %rsi
movl $0x0, %ecx
sbbq %rsi, %rcx
movq $-0x1, %rdx
movsd 0x8(%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x1404c
leaq (%rcx,%rdx), %rsi
incq %rsi
incq %rdx
cmpq $-0x1, %rsi
jne 0x1402e
xorl %edx, %edx
movslq %edx, %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdx
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rax,%rcx,8), %xmm1
movq 0x20(%rdi), %rax
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd (%rax,%rcx,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movq 0x28(%rdi), %rax
movsd (%rax,%rcx,8), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x26204(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
subq %rax, %rdx
shrq $0x3, %rdx
decq %rdx
jmp 0x1404c
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::setECI2ECEF(double)
void forrocket::Coordinate::setECI2ECEF(const double epoch_time) {
    double xi = wgs.omega * epoch_time;
    dcm.ECI2ECEF << std::cos(xi) , std::sin(xi), 0.0,
                    -std::sin(xi), std::cos(xi), 0.0,
                    0.0          ,          0.0, 1.0;
    dcm.ECEF2ECI = dcm.ECI2ECEF.transpose();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
mulsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x40(%rdi), %r15
callq 0x5640
leaq 0x10(%rsp), %r14
movq %r15, (%r14)
movq $0x0, 0x8(%r14)
movl $0x1, %eax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm0, 0x40(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
leaq 0x68(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x171ac
leaq 0x60(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x50e0
xorps 0x24365(%rip), %xmm0    # 0x3a6d0
leaq 0x58(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %r14, %rdi
callq 0x171ac
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x5640
leaq 0x50(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x171ac
leaq 0x48(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
leaq 0x40(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
leaq 0x38(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x171ac
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
leaq 0x30(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x171ac
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
cmpq $0x3, %rax
jne 0x164c0
cmpq $0x3, 0x20(%rsp)
jne 0x164c0
movsd 0x40(%rbx), %xmm0
movsd 0x48(%rbx), %xmm1
movsd %xmm0, 0x1f0(%rbx)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x1f8(%rbx)
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x200(%rbx)
movsd %xmm1, 0x208(%rbx)
movsd 0x60(%rbx), %xmm0
movsd %xmm0, 0x210(%rbx)
movsd 0x78(%rbx), %xmm0
movsd %xmm0, 0x218(%rbx)
movsd 0x50(%rbx), %xmm0
movsd %xmm0, 0x220(%rbx)
movsd 0x68(%rbx), %xmm0
movsd %xmm0, 0x228(%rbx)
movsd 0x80(%rbx), %xmm0
movsd %xmm0, 0x230(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x164a0
jmp 0x164a0
jmp 0x164a0
jmp 0x164a0
jmp 0x164a0
jmp 0x164a0
jmp 0x164a0
movq 0x28(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x164c0
cmpq $0x3, 0x20(%rsp)
jne 0x164c0
movq %rax, %rdi
callq 0x55e0
leaq 0x24249(%rip), %rdi     # 0x3a710
leaq 0x242e0(%rip), %rsi     # 0x3a7ae
leaq 0x24301(%rip), %rcx     # 0x3a7d6
movl $0x78, %edx
callq 0x5230
nop
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::ECEF2LLH(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Eigen::Vector3d forrocket::Coordinate::ECEF2LLH(const Eigen::Vector3d pos_ECEF) {
    // return: degree
    double x = pos_ECEF[0];
    double y = pos_ECEF[1];
    double z = pos_ECEF[2];
    double lat, lon, height;
    double p = std::sqrt(x * x + y * y);
    double theta = std::atan2(z * wgs.a, (p * wgs.b));
    double e_dash_square = (wgs.a * wgs.a - wgs.b * wgs.b) / std::pow(wgs.b, 2);
    lat = std::atan2(z + e_dash_square * wgs.b * std::pow(std::sin(theta), 3), p - wgs.e_square * wgs.a * std::pow(std::cos(theta), 3));
    lon = std::atan2(y, x);
    double N = wgs.a / std::sqrt(1 - wgs.e_square * std::pow(std::sin(lat), 2));
    height = (p / std::cos(lat) - N);
    return Eigen::Vector3d(rad2deg(lat), rad2deg(lon), height);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
movsd 0x10(%rdx), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x30(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16806
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0x1680f
callq 0x52b0
movapd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd (%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x28(%r14), %xmm1
mulsd %xmm2, %xmm1
callq 0x5080
movsd %xmm0, 0x28(%rsp)
movsd (%r14), %xmm3
movsd 0x28(%r14), %xmm2
mulsd %xmm3, %xmm3
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, 0x20(%rsp)
callq 0x50e0
movsd 0x23a35(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x20(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
mulsd 0x30(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x5640
movsd 0x239fa(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x5080
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5080
movsd %xmm0, 0x30(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x28(%rsp), %xmm1
movsd 0x23dc5(%rip), %xmm0    # 0x3a6e0
subsd %xmm1, %xmm0
ucomisd 0x23dc1(%rip), %xmm0    # 0x3a6e8
jb 0x1692f
sqrtsd %xmm0, %xmm0
jmp 0x16934
callq 0x52b0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5640
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x727d
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x727d
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%rbx)
movsd %xmm0, 0x8(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::LLH2ECEF(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Eigen::Vector3d forrocket::Coordinate::LLH2ECEF(const Eigen::Vector3d pos_LLH) {
    // Input: degree
    double lat = deg2rad(pos_LLH[0]);
    double lon = deg2rad(pos_LLH[1]);
    double height = pos_LLH[2];
    double x, y ,z;
    double N = wgs.a / std::sqrt(1 - wgs.e_square * std::pow(std::sin(lat), 2));
    // double N = std::pow(wgs.a, 2) / std::sqrt(std::pow(wgs.a, 2) * std::pow(std::cos(lat), 2) + std::pow(wgs.b, 2) * std::pow(std::sin(lat), 2));
    x = (N + height) * std::cos(lat) * std::cos(lon);
    y = (N + height) * std::cos(lat) * std::sin(lon);
    z = (N * (1 - wgs.e_square) + height) * std::sin(lat);
    // z = (N * std::pow(wgs.b / wgs.a, 2) + height) * std::sin(lat);
    return Eigen::Vector3d(x, y, z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
callq 0x726c
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%r15), %xmm0
callq 0x726c
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%r14), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x50e0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
movsd 0x23cc6(%rip), %xmm0    # 0x3a6e0
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16a2e
sqrtsd %xmm0, %xmm0
jmp 0x16a33
callq 0x52b0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x5640
mulsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5640
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x5640
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x23c2e(%rip), %xmm0    # 0x3a6e0
subsd 0x30(%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x50e0
mulsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd %xmm1, (%rbx)
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::EulerAngle()
Eigen::Vector3d forrocket::Coordinate::EulerAngle() {
    // return: radian
    double azimuth = std::atan2(dcm.NED2body(0, 1), dcm.NED2body(0, 0));
    double elevation = -std::asin(dcm.NED2body(0, 2));
    double roll = std::atan2(dcm.NED2body(1, 2), dcm.NED2body(2, 2));
    Eigen::Vector3d euler;
    euler << azimuth, elevation, roll;
    return euler;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xd0(%rsi), %xmm1
movsd 0xe8(%rsi), %xmm0
callq 0x5080
movsd %xmm0, 0x8(%rsp)
movsd 0x100(%r14), %xmm0
callq 0x5580
xorps 0x2372d(%rip), %xmm0    # 0x3a6d0
leaq 0x38(%rsp), %r15
movlps %xmm0, (%r15)
movsd 0x108(%r14), %xmm0
movsd 0x110(%r14), %xmm1
callq 0x5080
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movq %rbx, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movq %r15, %rsi
callq 0x1726a
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1726a
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq $0x3, %rax
jne 0x1702a
cmpq $0x1, 0x28(%rsp)
jne 0x1702a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x236df(%rip), %rdi     # 0x3a710
leaq 0x23776(%rip), %rsi     # 0x3a7ae
leaq 0x23961(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
movq 0x30(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x17069
cmpq $0x1, 0x28(%rsp)
jne 0x17069
movq %rax, %rdi
callq 0x55e0
callq 0x58b1
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
forrocket::DateTime::DateTime(unsigned int year, unsigned int month, unsigned int day, unsigned int hour, unsigned int min) {
    this->year = year;
    this->month = month;
    this->day = day;
    this->hour = hour;
    this->min = min;
    this->sec = 0;
    this->msec = 0;
}

// Assembly:
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movq $0x0, 0x14(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
forrocket::DateTime::DateTime(unsigned int year, unsigned int month, unsigned int day, unsigned int hour, unsigned int min, unsigned int sec) {
    this->year = year;
    this->month = month;
    this->day = day;
    this->hour = hour;
    this->min = min;
    this->sec = sec;
    this->msec = 0;
}

// Assembly:
movl 0x8(%rsp), %eax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
forrocket::DateTime::DateTime(unsigned int year, unsigned int month, unsigned int day, unsigned int hour, unsigned int min, unsigned int sec, unsigned int msec) {
    this->year = year;
    this->month = month;
    this->day = day;
    this->hour = hour;
    this->min = min;
    this->sec = sec;
    this->msec = msec;
}

// Assembly:
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %r10d
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %r10d, 0x14(%rdi)
movl %eax, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime(forrocket::DateTime const&)
forrocket::DateTime::DateTime(const DateTime& from) {
    year = from.year;
    month = from.month;
    day = from.day;
    hour = from.hour;
    min = from.min;
    sec = from.sec;
    msec = from.msec;
}

// Assembly:
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x14(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x178f0
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
movl 0x8(%rsi), %ecx
movl %ecx, 0x8(%rax)
movl 0xc(%rsi), %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rsi), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rsi), %ecx
movl %ecx, 0x18(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rsi), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %edx
movl %edx, 0xc(%rdi)
movl 0x10(%rsi), %edi
movl %edi, 0x10(%rax)
movl 0x14(%rsi), %r9d
movl %r9d, 0x14(%rax)
cvttsd2si %xmm0, %r8
movl %r8d, %r10d
cvtsi2sd %r10, %xmm1
subsd %xmm1, %xmm0
mulsd 0x2318e(%rip), %xmm0    # 0x3aac0
cvttsd2si %xmm0, %r10
addl 0x18(%rsi), %r10d
movl %r10d, 0x18(%rax)
cmpl $0x3e8, %r10d           # imm = 0x3E8
jb 0x1795a
incl %r9d
movl %r9d, 0x14(%rax)
addl $0xfffffc18, %r10d      # imm = 0xFFFFFC18
movl %r10d, 0x18(%rax)
addl 0x14(%rax), %r8d
movl %r8d, 0x14(%rax)
cmpl $0x3c, %r8d
jb 0x17989
movl %r8d, %esi
movl $0x88888889, %r9d       # imm = 0x88888889
imulq %rsi, %r9
shrq $0x25, %r9
addl %r9d, %edi
movl %edi, 0x10(%rax)
imull $-0x3c, %r9d, %esi
addl %r8d, %esi
movl %esi, 0x14(%rax)
movl 0x10(%rax), %esi
cmpl $0x3c, %esi
jb 0x179b0
movl %esi, %edi
movl $0x88888889, %r8d       # imm = 0x88888889
imulq %rdi, %r8
shrq $0x25, %r8
addl %r8d, %edx
movl %edx, 0xc(%rax)
imull $-0x3c, %r8d, %edx
addl %esi, %edx
movl %edx, 0x10(%rax)
movl 0xc(%rax), %edx
cmpl $0x18, %edx
jb 0x179d7
movl %edx, %esi
movl $0xaaaaaaab, %edi       # imm = 0xAAAAAAAB
imulq %rsi, %rdi
shrq $0x24, %rdi
addl %edi, %ecx
movl %ecx, 0x8(%rax)
shll $0x3, %edi
leal (%rdi,%rdi,2), %ecx
subl %ecx, %edx
movl %edx, 0xc(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x178f2
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 0x23087(%rip), %xmm1    # 0x3aad0
movl 0x14(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x2307b(%rip), %xmm2    # 0x3aad8
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 0x23056(%rip), %xmm0    # 0x3aae0
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x2304e(%rip), %xmm1    # 0x3aae8
addsd %xmm0, %xmm1
addsd 0x2304a(%rip), %xmm0    # 0x3aaf0
movsd %xmm1, 0x8(%rbx)
divsd 0x23045(%rip), %xmm0    # 0x3aaf8
movsd 0x23045(%rip), %xmm1    # 0x3ab00
mulsd %xmm0, %xmm1
addsd 0x23041(%rip), %xmm1    # 0x3ab08
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x23039(%rip), %xmm2    # 0x3ab10
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x227b8(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x23023(%rip), %xmm0    # 0x3ab18
addsd (%rsp), %xmm0
mulsd 0x2301e(%rip), %xmm0    # 0x3ab20
movsd %xmm0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22f6e(%rip), %xmm1    # 0x3aad0
movl 0x14(%rsi), %eax
cvtsi2sd %rax, %xmm0
movsd 0x22f66(%rip), %xmm2    # 0x3aad8
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 0x22f43(%rip), %xmm0    # 0x3aae0
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22f3b(%rip), %xmm0    # 0x3aaf0
divsd 0x22f3b(%rip), %xmm0    # 0x3aaf8
movsd 0x22f3b(%rip), %xmm1    # 0x3ab00
mulsd %xmm0, %xmm1
addsd 0x22f37(%rip), %xmm1    # 0x3ab08
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x22f2f(%rip), %xmm2    # 0x3ab10
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x226ae(%rip), %xmm1    # 0x3a2a0
callq 0x55d0
mulsd 0x22f19(%rip), %xmm0    # 0x3ab18
addsd (%rsp), %xmm0
mulsd 0x22f14(%rip), %xmm0    # 0x3ab20
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17328
movq %r15, %rdi
movq %rbx, %rsi
callq 0x178c0
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x179d8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17328
movq %r15, %rdi
movq %rbx, %rsi
callq 0x178c0
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 0x179d8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22db5(%rip), %xmm2    # 0x3ab28
movsd 0x22db5(%rip), %xmm1    # 0x3ab30
addsd %xmm2, %xmm1
divsd 0x22db1(%rip), %xmm1    # 0x3ab38
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
addsd %xmm1, %xmm2
mulsd 0x22da5(%rip), %xmm1    # 0x3ab40
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm2
addsd 0x22d99(%rip), %xmm2    # 0x3ab48
movsd 0x22d99(%rip), %xmm1    # 0x3ab50
addsd %xmm2, %xmm1
movsd 0x22d95(%rip), %xmm3    # 0x3ab58
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 0x22d75(%rip), %xmm3    # 0x3ab60
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
movsd 0x22d6d(%rip), %xmm4    # 0x3ab68
mulsd %xmm3, %xmm4
cvttsd2si %xmm4, %rax
movl %eax, %eax
xorps %xmm4, %xmm4
cvtsi2sd %rax, %xmm4
subsd %xmm4, %xmm2
cvttsd2si %xmm2, %rcx
movsd 0x22d51(%rip), %xmm2    # 0x3ab70
addsd %xmm3, %xmm2
divsd 0x22d4d(%rip), %xmm3    # 0x3ab78
cvttsd2si %xmm3, %rax
shll $0x2, %eax
leal (%rax,%rax,2), %eax
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
subsd %xmm3, %xmm2
cvttsd2si %xmm2, %rdx
addsd 0x22d31(%rip), %xmm1    # 0x3ab80
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 0x22c69(%rip), %xmm0    # 0x3aae0
cvttsd2si %xmm0, %r8
movl %r8d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
mulsd 0x22c45(%rip), %xmm0    # 0x3aad8
movq %rdi, %rbx
cvttsd2si %xmm0, %r9
imull $0x3b, %r9d, %eax
movl %eax, (%rsp)
callq 0x17378
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd 0x22cc2(%rip), %xmm0    # 0x3ab88
movupd %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
divsd 0x22be6(%rip), %xmm0    # 0x3aac0
jbe 0x17ee6
movq %rsp, %rdi
callq 0x17f94
jmp 0x17eee
movq %rsp, %rdi
callq 0x18209
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18546
movq (%r14), %rdi
testq %rdi, %rdi
je 0x17f11
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq (%rbx), %rax
movsd 0x10(%rax), %xmm0
divsd 0x31477(%rip), %xmm0    # 0x49398
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x17f31
sqrtsd %xmm0, %xmm0
jmp 0x17f36
callq 0x52b0
mulsd 0x31472(%rip), %xmm0    # 0x493b0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x17f5b
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x17f66
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x7c14
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x17f75
jmp 0x17f75
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17f8c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22304(%rip), %xmm0    # 0x3a6e0
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_O1/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 0x2278e(%rip), %xmm1    # 0x3abb0
ucomisd %xmm0, %xmm1
jae 0x18469
movsd 0x22788(%rip), %xmm1    # 0x3abb8
ucomisd %xmm0, %xmm1
jbe 0x18476
addsd 0x227ba(%rip), %xmm0    # 0x3abf8
divsd 0x227ba(%rip), %xmm0    # 0x3ac00
mulsd %xmm0, %xmm0
movsd 0x2228e(%rip), %xmm1    # 0x3a6e0
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x1849e
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x184a7
movsd 0x22737(%rip), %xmm0    # 0x3aba8
jmp 0x184fe
movsd 0x22742(%rip), %xmm1    # 0x3abc0
ucomisd %xmm0, %xmm1
jbe 0x184b9
addsd 0x22754(%rip), %xmm0    # 0x3abe0
mulsd 0x22754(%rip), %xmm0    # 0x3abe8
addsd 0x22754(%rip), %xmm0    # 0x3abf0
jmp 0x184fe
movapd %xmm1, %xmm0
callq 0x52b0
mulsd 0x22759(%rip), %xmm0    # 0x3ac08
addsd 0x22759(%rip), %xmm0    # 0x3ac10
jmp 0x184fe
movsd 0x30eaf(%rip), %xmm1    # 0x49370
movsd 0x226f7(%rip), %xmm2    # 0x3abc0
addsd %xmm1, %xmm2
addsd %xmm0, %xmm1
addsd 0x226ef(%rip), %xmm0    # 0x3abc8
divsd %xmm1, %xmm2
mulsd 0x226eb(%rip), %xmm0    # 0x3abd0
mulsd %xmm2, %xmm0
callq 0x55f0
mulsd 0x226e2(%rip), %xmm0    # 0x3abd8
addsd 0x225c2(%rip), %xmm0    # 0x3aac0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19934
leaq 0xa0(%rbx), %r14
movq %r14, %rdi
callq 0x19934
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x1996a
movq %rsp, %rsi
movq %r14, %rdi
callq 0x19cc2
movq 0x80(%rsp), %rdi
callq 0x53d0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x186c1
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x186d8
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x186ef
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18706
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x1996a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19cc2
movq 0x80(%rsp), %rdi
callq 0x53d0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x18740
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x18757
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1876e
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18785
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x18796
jmp 0x187a3
movq %rax, %r15
movq %rsp, %rdi
callq 0x18cce
jmp 0x187a6
movq %rax, %r15
movq %r14, %rdi
callq 0x18cce
jmp 0x187b3
movq %rax, %r15
movq %rbx, %rdi
callq 0x18cce
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %al
movb %al, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
cmpb $0x1, (%rsi)
jne 0x19c42
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1363e
jmp 0x19c9a
movq %rdi, %r12
cmpb $0x1, 0x1(%r14)
jne 0x19c8d
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x140be
leaq 0x68(%r12), %rdi
leaq 0x68(%r14), %rsi
callq 0x140be
movl $0x80, %esi
leaq (%r12,%rsi), %rdi
addq %r14, %rsi
leaq 0x7(%rsp), %rdx
callq 0x19dcf
movl 0x98(%r14), %eax
movl %eax, 0x98(%r12)
jmp 0x19c9a
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 0x19d96
movq %rbx, %rdi
callq 0x19d66
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19d43
movq %rsi, %r14
movb (%rsi), %al
movb %al, (%rbx)
movb 0x1(%rsi), %al
movb %al, 0x1(%rbx)
cmpb $0x1, (%rsi)
jne 0x19cf2
addq $0x10, %r14
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1363e
jmp 0x19d43
cmpb $0x1, 0x1(%r14)
jne 0x19d38
leaq 0x50(%r14), %rsi
leaq 0x50(%rbx), %rdi
callq 0x140be
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
callq 0x140be
movl $0x80, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
leaq 0x7(%rsp), %rdx
callq 0x19dcf
movl 0x98(%r14), %eax
movl %eax, 0x98(%rbx)
jmp 0x19d43
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
jmp 0x1a1d1
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x1a1f1
cmpq $0x1, 0x10(%rsp)
jne 0x1a1f1
movq %rax, %rdi
callq 0x55e0
leaq 0x20518(%rip), %rdi     # 0x3a710
leaq 0x205af(%rip), %rsi     # 0x3a7ae
leaq 0x2079a(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17896
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x17c58
leaq 0x138(%rsp), %r12
movq %r12, %rdi
callq 0x152d4
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 0xd0(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x169a6
leaq 0x18(%rbx), %r13
movups 0x18(%rbx), %xmm0
movaps (%r14), %xmm1
movups %xmm1, 0x18(%rbx)
movaps %xmm0, (%r14)
movsd 0x10(%r14), %xmm0
movsd 0x28(%rbx), %xmm1
movsd %xmm1, 0x10(%r14)
movsd %xmm0, 0x28(%rbx)
movsd 0x38(%r15), %xmm0
movq %r12, %rdi
callq 0x162e4
leaq 0x328(%rsp), %rax
movupd 0x18(%rbx), %xmm0
movupd 0x20(%rbx), %xmm1
movupd 0x28(%rbx), %xmm4
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rax), %xmm2
mulpd %xmm0, %xmm2
movupd 0x18(%rax), %xmm0
movupd 0x30(%rax), %xmm3
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm3, %xmm4
addpd %xmm1, %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 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a6c6
movq %r14, 0x30(%r15)
movq 0x10(%r15), %rax
movq 0x20(%r15), %rcx
movsd (%rax), %xmm0
movsd 0x18(%rax), %xmm1
mulsd (%rcx), %xmm0
mulsd 0x8(%rcx), %xmm1
movsd 0x30(%rax), %xmm2
mulsd 0x10(%rcx), %xmm2
addsd %xmm1, %xmm2
addsd %xmm0, %xmm2
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_O1/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, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x60(%rdi)
movq %rsp, %rdi
movq %rbx, (%rdi)
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a8f6
cmpq $0x1, 0x10(%rsp)
jne 0x1a8f6
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a8f6
cmpq $0x1, 0x10(%rsp)
jne 0x1a8f6
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a8f6
cmpq $0x1, 0x10(%rsp)
jne 0x1a8f6
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 0x1726a
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x1726a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x1a8f6
cmpq $0x1, 0x10(%rsp)
jne 0x1a8f6
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1a8d6
jmp 0x1a8d6
jmp 0x1a8d6
jmp 0x1a8d6
jmp 0x1a8d6
jmp 0x1a8d6
jmp 0x1a8d6
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x1a8f6
cmpq $0x1, 0x10(%rsp)
jne 0x1a8f6
movq %rax, %rdi
callq 0x55e0
leaq 0x1fe13(%rip), %rdi     # 0x3a710
leaq 0x1feaa(%rip), %rsi     # 0x3a7ae
leaq 0x20095(%rip), %rcx     # 0x3a9a0
movl $0x78, %edx
callq 0x5230
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19934
leaq 0xf8(%rbx), %r15
movq %r15, %rdi
callq 0x19934
leaq 0x8(%rbx), %rax
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x41(%rbx)
movups %xmm0, 0x28(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1996a
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x19cc2
movq 0xa0(%rsp), %rdi
callq 0x53d0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1b094
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1b0ae
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1b0c5
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1b0dc
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
leaq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x1996a
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x19cc2
movq 0xa0(%rsp), %rdi
callq 0x53d0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1b123
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1b13d
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1b154
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1b16b
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 0x1b18c
jmp 0x1b19b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x18cce
jmp 0x1b19e
movq %rax, %rbx
movq %r15, %rdi
callq 0x18cce
jmp 0x1b1ab
movq %rax, %rbx
movq %r14, %rdi
callq 0x18cce
movq %rbx, %rdi
callq 0x55e0
nop