LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::setWind2Body(double, double)
void forrocket::Coordinate::setWind2Body(const double alpha, const double beta) {
    // Input: radian
    dcm.wind2body << std::cos(alpha) * std::cos(beta), std::cos(alpha) * std::sin(beta), -std::sin(alpha),
                    -std::sin(beta)                  , std::cos(beta)                  ,              0.0,
                    std::sin(alpha) * std::cos(beta) , std::sin(alpha) * std::sin(beta), std::cos(alpha);
    dcm.body2wind = dcm.wind2body.transpose();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
leaq 0x118(%rdi), %r15
callq 0x5610
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5610
mulsd 0x8(%rsp), %xmm0
leaq 0x60(%rsp), %r14
movq %r15, (%r14)
andq $0x0, 0x8(%r14)
pushq $0x1
popq %rax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm0, 0x118(%rbx)
movsd 0x18(%rsp), %xmm0
callq 0x5610
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
mulsd 0x8(%rsp), %xmm0
leaq 0x58(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x18(%rsp), %xmm0
callq 0x50e0
xorpd 0x20839(%rip), %xmm0    # 0x31930
leaq 0x50(%rsp), %rsi
movlpd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x10(%rsp), %xmm0
callq 0x50e0
xorpd 0x20812(%rip), %xmm0    # 0x31930
leaq 0x48(%rsp), %rsi
movlpd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x10(%rsp), %xmm0
callq 0x5610
leaq 0x40(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x18(%rsp), %xmm0
callq 0x50e0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5610
mulsd 0x8(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x18(%rsp), %xmm0
callq 0x50e0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
mulsd 0x8(%rsp), %xmm0
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x18(%rsp), %xmm0
callq 0x5610
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x1262c
movq %r15, (%r14)
addq $0x238, %rbx            # imm = 0x238
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x128ab
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11229
jmp 0x11229
jmp 0x11229
jmp 0x11229
jmp 0x11229
jmp 0x11229
jmp 0x11229
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1262c
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5610
leaq 0x50(%rsp), %r14
movq %r15, (%r14)
andq $0x0, 0x8(%r14)
pushq $0x1
popq %rax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm0, 0x40(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
leaq 0x48(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x40(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x50e0
xorps 0x20035(%rip), %xmm0    # 0x31930
leaq 0x38(%rsp), %rsi
movlps %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x5610
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x28(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x12584
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x1262c
movq %r15, (%r14)
addq $0x1f0, %rbx            # imm = 0x1F0
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x128ab
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x119b3
jmp 0x119b3
jmp 0x119b3
jmp 0x119b3
jmp 0x119b3
jmp 0x119b3
jmp 0x119b3
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1262c
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::setECEF2NED(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
void forrocket::Coordinate::setECEF2NED(const Eigen::Vector3d pos_LLH) {
    // Input: degree
    double lat = deg2rad(pos_LLH(0));
    double lon = deg2rad(pos_LLH(1));

    dcm.ECEF2NED << -std::sin(lat) * std::cos(lon), -std::sin(lat) * std::sin(lon), std::cos(lat),
                    -std::sin(lon)                 ,                  std::cos(lon),             0,
                    -std::cos(lat) * std::cos(lon) , -std::cos(lat) * std::sin(lon), -std::sin(lat);
    dcm.NED2ECEF = dcm.ECEF2NED.transpose();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x5a6c
movsd %xmm0, (%rsp)
movsd 0x8(%r14), %xmm0
callq 0x5a6c
movsd %xmm0, 0x8(%rsp)
leaq 0x88(%rbx), %r15
movsd (%rsp), %xmm0
callq 0x50e0
xorps 0x1ff1f(%rip), %xmm0    # 0x31930
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5610
mulsd 0x10(%rsp), %xmm0
leaq 0x60(%rsp), %r14
movq %r15, (%r14)
andq $0x0, 0x8(%r14)
pushq $0x1
popq %rax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm0, 0x88(%rbx)
movsd (%rsp), %xmm0
callq 0x50e0
xorps 0x1fed8(%rip), %xmm0    # 0x31930
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
mulsd 0x10(%rsp), %xmm0
leaq 0x58(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd (%rsp), %xmm0
callq 0x5610
leaq 0x50(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x50e0
xorpd 0x1fe7d(%rip), %xmm0    # 0x31930
leaq 0x48(%rsp), %rsi
movlpd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x5610
leaq 0x40(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x12584
movq %rax, %r14
movsd (%rsp), %xmm0
callq 0x5610
xorps 0x1fe28(%rip), %xmm0    # 0x31930
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5610
mulsd 0x10(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd (%rsp), %xmm0
callq 0x5610
xorps 0x1fded(%rip), %xmm0    # 0x31930
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
mulsd 0x10(%rsp), %xmm0
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
movq %rax, %r14
movsd (%rsp), %xmm0
callq 0x50e0
xorpd 0x1fdb1(%rip), %xmm0    # 0x31930
leaq 0x20(%rsp), %rsi
movlpd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x12584
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x1262c
movq %r15, (%r14)
addq $0x1a8, %rbx            # imm = 0x1A8
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x128ab
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11bcf
jmp 0x11bcf
jmp 0x11bcf
jmp 0x11bcf
jmp 0x11bcf
jmp 0x11bcf
jmp 0x11bcf
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1262c
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd 0x8(%rdx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rdx), %xmm3
movsd %xmm3, 0x8(%rsp)
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd (%rsi), %xmm0
mulsd %xmm3, %xmm0
movsd 0x28(%rsi), %xmm1
mulsd %xmm2, %xmm1
callq 0x5070
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 0x1f7bf(%rip), %xmm1    # 0x31438
callq 0x55a0
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 0x5610
movsd 0x1f784(%rip), %xmm1    # 0x31438
callq 0x55a0
mulsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x5070
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x5070
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 0x1fc17(%rip), %xmm0    # 0x31940
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x11d3d
sqrtsd %xmm0, %xmm0
jmp 0x11d42
callq 0x52a0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5610
movsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
subsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5a7d
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x5a7d
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_O2/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 $0x70, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
callq 0x5a6c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%r15), %xmm0
callq 0x5a6c
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x1fb16(%rip), %xmm0    # 0x31940
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x11e3e
sqrtsd %xmm0, %xmm0
jmp 0x11e43
callq 0x52a0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5610
movaps %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x5610
movaps %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5610
movaps %xmm0, 0x40(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x50e0
movaps %xmm0, 0x20(%rsp)
movsd 0x1fa95(%rip), %xmm0    # 0x31940
subsd 0x30(%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
mulsd 0x8(%rsp), %xmm0
movapd 0x50(%rsp), %xmm2
unpcklpd 0x40(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
movapd 0x60(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5070
movsd %xmm0, 0x8(%rsp)
movsd 0x100(%r14), %xmm0
callq 0x5550
xorps 0x1f5f5(%rip), %xmm0    # 0x31930
leaq 0x18(%rsp), %r15
movlps %xmm0, (%r15)
movsd 0x108(%r14), %xmm0
movsd 0x110(%r14), %xmm1
callq 0x5070
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movq %r15, %rsi
callq 0x126a8
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x126a8
leaq 0x20(%rsp), %rdi
callq 0x12750
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andl $0x0, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
forrocket::DateTime::DateTime(std::string datetime_str) {
    auto datetime_str_vec = split(datetime_str, ' ');
    auto date_str = datetime_str_vec[0];
    auto time_str = datetime_str_vec[1];

    auto date_str_vec = split(date_str, '/');
    year = std::stoi(date_str_vec[0]);
    month = std::stoi(date_str_vec[1]);
    day = std::stoi(date_str_vec[2]);

    auto time_str_vec = split(time_str, ':');
    hour = std::stoi(time_str_vec[0]);
    min = std::stoi(time_str_vec[1]);
    auto sec_str_vec = split(time_str_vec[2], '.');
    sec = std::stoi(sec_str_vec[0]);
    msec = std::stoi(sec_str_vec[1]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x5d12
movq (%r14), %rsi
leaq 0x88(%rsp), %rdi
callq 0x5460
movq 0x50(%rsp), %rsi
addq $0x20, %rsi
leaq 0x68(%rsp), %rdi
callq 0x5460
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
pushq $0x2f
popq %rdx
callq 0x5d12
movq 0x20(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, (%rbx)
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0x4(%rbx)
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
pushq $0x3a
popq %rdx
callq 0x5d12
movq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0xc(%rbx)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0x10(%rbx)
movq 0x8(%rsp), %rsi
addq $0x40, %rsi
leaq 0x38(%rsp), %rdi
pushq $0x2e
popq %rdx
callq 0x5d12
movq 0x38(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0x14(%rbx)
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x12fe2
movl %eax, 0x18(%rbx)
leaq 0x38(%rsp), %rdi
callq 0x5e14
leaq 0x8(%rsp), %rdi
callq 0x5e14
leaq 0x20(%rsp), %rdi
callq 0x5e14
leaq 0x68(%rsp), %rdi
callq 0x5688
leaq 0x88(%rsp), %rdi
callq 0x5688
leaq 0x50(%rsp), %rdi
callq 0x5e14
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
jmp 0x12eac
jmp 0x12ebb
movq %rax, %rbx
jmp 0x12ec8
movq %rax, %rbx
jmp 0x12ed2
movq %rax, %rbx
jmp 0x12edf
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5e14
jmp 0x12eaf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5e14
jmp 0x12ebe
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5e14
leaq 0x68(%rsp), %rdi
callq 0x5688
leaq 0x88(%rsp), %rdi
callq 0x5688
leaq 0x50(%rsp), %rdi
callq 0x5e14
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x12ef2
movsd 0x8(%rsp), %xmm1
cvttsd2si %xmm1, %rax
movl %eax, %ecx
cvtsi2sd %rcx, %xmm0
subsd %xmm0, %xmm1
mulsd 0x1f2c9(%rip), %xmm1    # 0x32220
cvttsd2si %xmm1, %rdx
addl 0x18(%rbx), %edx
movl %edx, 0x18(%rbx)
movl 0x14(%rbx), %ecx
cmpl $0x3e8, %edx            # imm = 0x3E8
jb 0x12f78
incl %ecx
addl $0xfffffc18, %edx       # imm = 0xFFFFFC18
movl %edx, 0x18(%rbx)
addl %eax, %ecx
movl %ecx, 0x14(%rbx)
pushq $0x3c
popq %rdi
cmpl $0x3b, %ecx
jbe 0x12f9d
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movl %eax, %esi
imull $-0x3c, %eax, %eax
addl 0x10(%rbx), %esi
movl %esi, 0x10(%rbx)
addl %ecx, %eax
movl %eax, 0x14(%rbx)
jmp 0x12fa0
movl 0x10(%rbx), %esi
cmpl $0x3b, %esi
jbe 0x12fbd
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %eax, %ecx
imull $-0x3c, %eax, %eax
addl 0xc(%rbx), %ecx
movl %ecx, 0xc(%rbx)
addl %esi, %eax
movl %eax, 0x10(%rbx)
jmp 0x12fc0
movl 0xc(%rbx), %ecx
cmpl $0x18, %ecx
jb 0x12fd9
pushq $0x18
popq %rsi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
addl %eax, 0x8(%rbx)
imull $-0x18, %eax, %eax
addl %ecx, %eax
movl %eax, 0xc(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12f26
movq %r14, %rsi
callq 0x1316a
movsd %xmm0, (%rbx)
movsd 0x1f13c(%rip), %xmm1    # 0x32230
addsd %xmm0, %xmm1
addsd 0x1f138(%rip), %xmm0    # 0x32238
movsd %xmm1, 0x8(%rbx)
divsd 0x1f133(%rip), %xmm0    # 0x32240
movsd 0x1f133(%rip), %xmm1    # 0x32248
mulsd %xmm0, %xmm1
addsd 0x1f12f(%rip), %xmm1    # 0x32250
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x1f127(%rip), %xmm2    # 0x32258
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x1e2f6(%rip), %xmm1    # 0x31438
callq 0x55a0
mulsd 0x1f111(%rip), %xmm0    # 0x32260
addsd (%rsp), %xmm0
mulsd 0x1f10c(%rip), %xmm0    # 0x32268
movsd %xmm0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %edi
movl 0x4(%rsi), %r8d
imull $0x16f, %edi, %ecx      # imm = 0x16F
leal 0x9(%r8), %eax
pushq $0xc
popq %r9
xorl %edx, %edx
divl %r9d
addl %edi, %eax
imull $0x7, %eax, %edi
imull $0x113, %r8d, %eax      # imm = 0x113
pushq $0x9
popq %r8
xorl %edx, %edx
divl %r8d
addl 0x8(%rsi), %ecx
shrl $0x2, %edi
addl %eax, %ecx
subl %edi, %ecx
cvtsi2sd %rcx, %xmm1
addsd 0x1f0c1(%rip), %xmm1    # 0x32270
movl 0x14(%rsi), %eax
cvtsi2sd %rax, %xmm0
movsd 0x1f0b9(%rip), %xmm2    # 0x32278
divsd %xmm2, %xmm0
movl 0x10(%rsi), %eax
cvtsi2sd %rax, %xmm3
addsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movl 0xc(%rsi), %eax
cvtsi2sd %rax, %xmm0
addsd %xmm3, %xmm0
divsd 0x1f099(%rip), %xmm0    # 0x32280
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f039(%rip), %xmm0    # 0x32238
divsd 0x1f039(%rip), %xmm0    # 0x32240
movsd 0x1f039(%rip), %xmm1    # 0x32248
mulsd %xmm0, %xmm1
addsd 0x1f035(%rip), %xmm1    # 0x32250
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x1f02d(%rip), %xmm2    # 0x32258
addsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
movsd 0x1e1fc(%rip), %xmm1    # 0x31438
callq 0x55a0
mulsd 0x1f017(%rip), %xmm0    # 0x32260
addsd (%rsp), %xmm0
mulsd 0x1f012(%rip), %xmm0    # 0x32268
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12cb8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12f08
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x130c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12cb8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12f08
andq $0x0, 0x38(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%r14)
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x130c0
// File: /workspace/github_cpp_makefile_star2_O2/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, %xmm1
subsd %xmm1, %xmm0
addsd 0x1eed1(%rip), %xmm1    # 0x32288
movsd 0x1eed1(%rip), %xmm2    # 0x32290
addsd %xmm1, %xmm2
divsd 0x1eecd(%rip), %xmm2    # 0x32298
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
addsd %xmm2, %xmm1
mulsd 0x1eec1(%rip), %xmm2    # 0x322a0
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm2, %xmm1
addsd 0x1eeb5(%rip), %xmm1    # 0x322a8
movsd 0x1eeb5(%rip), %xmm2    # 0x322b0
addsd %xmm1, %xmm2
movsd 0x1eeb1(%rip), %xmm3    # 0x322b8
divsd %xmm3, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm2, %xmm3
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
subsd %xmm3, %xmm1
movapd %xmm1, %xmm3
divsd 0x1ee91(%rip), %xmm3    # 0x322c0
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
movsd 0x1ee89(%rip), %xmm4    # 0x322c8
mulsd %xmm3, %xmm4
cvttsd2si %xmm4, %rax
movl %eax, %eax
cvtsi2sd %rax, %xmm4
subsd %xmm4, %xmm1
cvttsd2si %xmm1, %rcx
movsd 0x1ee70(%rip), %xmm1    # 0x322d0
addsd %xmm3, %xmm1
divsd 0x1ee6c(%rip), %xmm3    # 0x322d8
cvttsd2si %xmm3, %rax
imull $0xc, %eax, %eax
cvtsi2sd %rax, %xmm3
subsd %xmm3, %xmm1
cvttsd2si %xmm1, %r10
addsd 0x1ee56(%rip), %xmm2    # 0x322e0
leal 0x7(%r10), %eax
pushq $0xa
popq %rsi
xorl %edx, %edx
divl %esi
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rsi
mulsd 0x1edd6(%rip), %xmm0    # 0x32280
cvttsd2si %xmm0, %r8
movl %r8d, %eax
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
mulsd 0x1edb5(%rip), %xmm0    # 0x32278
movq %rdi, %rbx
cvttsd2si %xmm0, %r9
imull $0x3b, %r9d, %eax
movl %eax, (%rsp)
movl %r10d, %edx
callq 0x12cf8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
ucomisd 0x1eded(%rip), %xmm0    # 0x322e8
xorpd %xmm1, %xmm1
movupd %xmm1, (%rdi)
divsd 0x1ed15(%rip), %xmm0    # 0x32220
jbe 0x13517
movq %rsp, %rdi
callq 0x13593
jmp 0x1351f
movq %rsp, %rdi
callq 0x1376b
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13a66
movq %r14, %rdi
callq 0x6002
movq (%rbx), %rax
movsd 0x10(%rax), %xmm0
divsd 0x35e4b(%rip), %xmm0    # 0x49390
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x13555
sqrtsd %xmm0, %xmm0
jmp 0x1355a
callq 0x52a0
mulsd 0x35e46(%rip), %xmm0    # 0x493a8
movq %rsp, %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x62f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x13580
jmp 0x13580
movq %rax, %r14
movq %rbx, %rdi
callq 0x6002
movq %r14, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e032(%rip), %xmm0    # 0x31940
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_O2/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 0x1e9ac(%rip), %xmm1    # 0x32300
ucomisd %xmm0, %xmm1
jae 0x13998
movsd 0x1e9a6(%rip), %xmm1    # 0x32308
ucomisd %xmm0, %xmm1
jbe 0x139a5
addsd 0x1e9d8(%rip), %xmm0    # 0x32348
divsd 0x1e9d8(%rip), %xmm0    # 0x32350
mulsd %xmm0, %xmm0
movsd 0x1dfbc(%rip), %xmm1    # 0x31940
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x139cd
sqrtsd %xmm1, %xmm0
jmp 0x139d6
movsd 0x1e958(%rip), %xmm0    # 0x322f8
jmp 0x13a2d
movsd 0x1e963(%rip), %xmm1    # 0x32310
ucomisd %xmm0, %xmm1
jbe 0x139e8
addsd 0x1e975(%rip), %xmm0    # 0x32330
mulsd 0x1e975(%rip), %xmm0    # 0x32338
addsd 0x1e975(%rip), %xmm0    # 0x32340
jmp 0x13a2d
movapd %xmm1, %xmm0
callq 0x52a0
mulsd 0x1e97a(%rip), %xmm0    # 0x32358
addsd 0x1e97a(%rip), %xmm0    # 0x32360
jmp 0x13a2d
movsd 0x35978(%rip), %xmm1    # 0x49368
movsd 0x1e918(%rip), %xmm2    # 0x32310
addsd %xmm1, %xmm2
addsd %xmm0, %xmm1
addsd 0x1e910(%rip), %xmm0    # 0x32318
divsd %xmm1, %xmm2
mulsd 0x1e90c(%rip), %xmm0    # 0x32320
mulsd %xmm2, %xmm0
callq 0x55c0
mulsd 0x1e903(%rip), %xmm0    # 0x32328
addsd 0x1e7f3(%rip), %xmm0    # 0x32220
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14f9c
leaq 0xa0(%rbx), %r14
movq %r14, %rdi
callq 0x14f9c
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x14fd0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x15220
movq %rsp, %rdi
callq 0x13f1a
movq %rsp, %rdi
xorps %xmm0, %xmm0
callq 0x14fd0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x15220
movq %rsp, %rdi
callq 0x13f1a
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13bf0
jmp 0x13bfd
movq %rax, %r15
movq %rsp, %rdi
callq 0x13f1a
jmp 0x13c00
movq %rax, %r15
movq %r14, %rdi
callq 0x13f1a
jmp 0x13c0d
movq %rax, %r15
movq %rbx, %rdi
callq 0x13f1a
movq %r15, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
leaq 0x50(%rdi), %r14
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
andq $0x0, 0x90(%rdi)
movb (%rsi), %cl
movb %cl, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
cmpb $0x1, %cl
jne 0x151e2
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xf3d8
jmp 0x151fe
testb %al, %al
je 0x151f4
addq $0x50, %rsi
movq %r14, %rdi
callq 0x15282
jmp 0x151fe
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x13f34
movq %rbx, %rdi
callq 0x13f54
movq %r15, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x15264
movb (%rsi), %cl
movb %cl, (%rbx)
movb 0x1(%rsi), %al
movb %al, 0x1(%rbx)
cmpb $0x1, %cl
jne 0x15247
addq $0x10, %rsi
leaq 0x10(%rbx), %rdi
callq 0xf3d8
jmp 0x15264
testb %al, %al
je 0x1525a
addq $0x50, %rsi
leaq 0x50(%rbx), %rdi
callq 0x15282
jmp 0x15264
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %r15
movq %r15, 0x10(%rdi)
movq %r15, 0x18(%rdi)
andq $0x0, (%rbx)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x18(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x30(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x48(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
addq $0x60, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %rbx, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%rbx)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x18(%rsp), %rdi
callq 0x12750
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
jmp 0x15669
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x370, %rsp            # imm = 0x370
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x44(%rsp), %r12
movq %r12, %rdi
callq 0x12ef2
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x132a0
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x10fe4
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x149bd
movups 0x30(%rbx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x40(%rbx), %rax
movq %rax, 0x10(%rdx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x11db4
leaq 0x18(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1496a
movsd 0x38(%r14), %xmm0
movq %r12, %rdi
callq 0x1187c
leaq 0x298(%rsp), %rax
movq %rax, (%r15)
movq %r13, 0x8(%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15ab6
addq $0x370, %rsp            # imm = 0x370
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %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)
leaq 0x18(%rsp), %rdi
movq %rbx, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %r15
movq %r15, 0x10(%rdi)
movq %r15, 0x18(%rdi)
andq $0x0, (%rbx)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x18(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x30(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x48(%rbx), %r12
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12750
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r15, 0x18(%r14)
andq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x126a8
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0x126a8
leaq 0x18(%rsp), %rdi
callq 0x12750
andq $0x0, 0x60(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x16194
jmp 0x16194
jmp 0x16194
jmp 0x16194
jmp 0x16194
jmp 0x16194
jmp 0x16194
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12750
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/rocket/parameter/velocity.cpp
// Function: forrocket::Velocity::Initialize(forrocket::DateTime, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&)
void forrocket::Velocity::Initialize(const DateTime datetime, const Eigen::Vector3d& NED, const Eigen::Vector3d& pos_LLH, const Eigen::Vector3d& pos_ECI) {
    SequenceClock clock(datetime);
    Coordinate coordinate;
    this->NED = NED;
    coordinate.setECEF2NED(pos_LLH);
    this->ECEF = coordinate.dcm.NED2ECEF * this->NED;
    coordinate.setECI2ECEF(clock.countup_time);
    this->ECI = coordinate.dcm.ECEF2ECI * this->ECEF + coordinate.dcm.EarthRotate * pos_ECI;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp            # imm = 0x378
movq %r8, (%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %r14
leaq 0x4c(%rsp), %r12
movq %r12, %rdi
callq 0x12ef2
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x132a0
leaq 0xb0(%rsp), %r12
movq %r12, %rdi
callq 0x10fe4
leaq 0x30(%r14), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x149bd
movq 0x10(%r13), %rax
leaq 0x30(%rsp), %rsi
movq %rax, 0x10(%rsi)
movups (%r13), %xmm0
movaps %xmm0, (%rsi)
movq %r12, %rdi
callq 0x119c8
leaq 0x258(%rsp), %rax
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rbx, 0x8(%r13)
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x15ab6
movsd 0x38(%r15), %xmm0
movq %r12, %rdi
callq 0x1187c
leaq 0x2a0(%rsp), %rax
leaq 0x330(%rsp), %rcx
movq %rax, (%r13)
movq %rbx, 0x8(%r13)
movq %rcx, 0x10(%r13)
movq (%rsp), %rax
movq %rax, 0x18(%r13)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1630d
addq $0x378, %rsp            # imm = 0x378
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movb $0x0, (%rdi)
leaq 0x58(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x41(%rdi)
movq %rbx, %rdi
callq 0x14f9c
leaq 0xf8(%r15), %r14
movq %r14, %rdi
callq 0x14f9c
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x41(%r15)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%r15)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%r15)
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x14fd0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x15220
leaq 0x20(%rsp), %rdi
callq 0x13f1a
leaq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x14fd0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x15220
leaq 0x20(%rsp), %rdi
callq 0x13f1a
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x167a3
jmp 0x167b2
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x13f1a
jmp 0x167b5
movq %rax, %r15
movq %r14, %rdi
callq 0x13f1a
jmp 0x167c2
movq %rax, %r15
movq %rbx, %rdi
callq 0x13f1a
movq %r15, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movb $0x0, (%rdi)
leaq 0x58(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x41(%rdi)
movq %rbx, %rdi
callq 0x14f9c
leaq 0xf8(%r15), %r14
movq %r14, %rdi
callq 0x14f9c
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x41(%r15)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x38(%r15)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%r15)
leaq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x14fd0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x15220
leaq 0x30(%rsp), %rdi
callq 0x13f1a
leaq 0x30(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x14fd0
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x15220
leaq 0x30(%rsp), %rdi
callq 0x13f1a
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%r15)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x48(%r15)
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x168f3
jmp 0x16902
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x13f1a
jmp 0x16905
movq %rax, %r15
movq %r14, %rdi
callq 0x13f1a
jmp 0x16912
movq %rax, %r15
movq %rbx, %rdi
callq 0x13f1a
movq %r15, %rdi
callq 0x55b0