LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sus304[P]ForRocket/src/commandline_option.cpp
// Function: forrocket::DisplayHelp()
void forrocket::DisplayHelp() {
    std::cout << "Usage: ForRocket [option] config.json" << std::endl;
    std::cout << "Option:" << std::endl;
    std::cout << "  -m                 Decrease column of trajectory log" << std::endl;
    std::cout << "  -q or --quite      Disable announce message." << std::endl;
    std::cout << "  -h or --help       Display this information and exit." << std::endl;
    std::cout << "  -v or --version    Display solver version and exit." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xdcec5(%rip), %rdi     # 0xe3fc0
leaq 0x89f16(%rip), %rsi     # 0x91018
callq 0x6420
movq %rax, %rdi
movq 0xdce67(%rip), %rsi     # 0xe3f78
callq 0x6470
movq 0xdcea3(%rip), %rdi     # 0xe3fc0
leaq 0x89f1a(%rip), %rsi     # 0x9103e
callq 0x6420
movq %rax, %rdi
movq 0xdce45(%rip), %rsi     # 0xe3f78
callq 0x6470
movq 0xdce81(%rip), %rdi     # 0xe3fc0
leaq 0x89f00(%rip), %rsi     # 0x91046
callq 0x6420
movq %rax, %rdi
movq 0xdce23(%rip), %rsi     # 0xe3f78
callq 0x6470
movq 0xdce5f(%rip), %rdi     # 0xe3fc0
leaq 0x89f15(%rip), %rsi     # 0x9107d
callq 0x6420
movq %rax, %rdi
movq 0xdce01(%rip), %rsi     # 0xe3f78
callq 0x6470
movq 0xdce3d(%rip), %rdi     # 0xe3fc0
leaq 0x89f22(%rip), %rsi     # 0x910ac
callq 0x6420
movq %rax, %rdi
movq 0xdcddf(%rip), %rsi     # 0xe3f78
callq 0x6470
movq 0xdce1b(%rip), %rdi     # 0xe3fc0
leaq 0x89f38(%rip), %rsi     # 0x910e4
callq 0x6420
movq %rax, %rdi
movq 0xdcdbd(%rip), %rsi     # 0xe3f78
callq 0x6470
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sus304[P]ForRocket/src/fileio.cpp
// Function: forrocket::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
std::vector<std::string> forrocket::split(std::string& line, char delimiter) {
    std::istringstream stream(line);
    std::string field;
    std::vector<std::string> res;
    while (getline(stream, field, delimiter)) {
        res.push_back(field);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movl $0x8, %edx
callq 0x6700
leaq -0x1b8(%rbp), %rdi
callq 0x65f0
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
callq 0x7930
movsbl -0x11(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x67e0
movq %rax, -0x1e8(%rbp)
jmp 0x75bd
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6540
movb %al, -0x1e9(%rbp)
jmp 0x75db
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x75e7
jmp 0x7636
movq -0x1d8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x7950
jmp 0x75fc
jmp 0x759d
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
callq 0x7870
leaq -0x1b8(%rbp), %rdi
callq 0x6898
leaq -0x198(%rbp), %rdi
callq 0x6230
jmp 0x767a
movb $0x1, -0x1b9(%rbp)
testb $0x1, -0x1b9(%rbp)
jne 0x7652
movq -0x1d8(%rbp), %rdi
callq 0x7870
leaq -0x1b8(%rbp), %rdi
callq 0x6898
leaq -0x198(%rbp), %rdi
callq 0x6230
movq -0x1e0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/json_control.cpp
// Function: forrocket::JsonControl::JsonControl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
forrocket::JsonControl::JsonControl(std::string json_file_path) {
    using json = nlohmann::json;
    std::ifstream json_ifs(json_file_path, std::ios::in);
    if (json_ifs.fail()) {
        std::cerr << "failed to open: " << json_file_path << std::endl;
        std::exit(1);
    }
    json_ifs >> json_obj;
    json_ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x240(%rbp)
movq %rdi, %rax
movq %rax, -0x238(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xa6a0
movq -0x230(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x66a0
jmp 0xa392
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x6030
movb %al, -0x241(%rbp)
jmp 0xa3b2
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0xa3c1
jmp 0xa44c
movq 0xd9c28(%rip), %rdi     # 0xe3ff0
leaq 0x876e1(%rip), %rsi     # 0x91ab0
callq 0x6420
movq %rax, -0x250(%rbp)
jmp 0xa3dd
movq -0x230(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x6400
movq %rax, -0x258(%rbp)
jmp 0xa3f9
movq -0x258(%rbp), %rdi
movq 0xd9b71(%rip), %rsi     # 0xe3f78
callq 0x6470
jmp 0xa40e
movl $0x1, %edi
callq 0x6500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xa484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6150
jmp 0xa484
movq -0x238(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0xa6e0
jmp 0xa461
leaq -0x218(%rbp), %rdi
callq 0x6110
jmp 0xa46f
leaq -0x218(%rbp), %rdi
callq 0x6150
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0xa820
movq -0x220(%rbp), %rdi
callq 0x6760
nopl (%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::need_sort(std::vector<double, std::allocator<double>> const&)
bool forrocket::interpolate::Interp1d::need_sort(const std::vector<double>& x) {
    double slope;
    for (int i=1; i < x.size(); ++i) {
        slope = x[i] - x[i-1];
        if (slope < 0) return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x25dc7
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x27ce0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x27ce0
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x25dba
movb $0x1, -0x1(%rbp)
jmp 0x25dcb
jmp 0x25dbc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25d57
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::ascending_order_sort(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void forrocket::interpolate::Interp1d::ascending_order_sort(std::vector<double>& x, std::vector<double>& y) {
    std::vector<std::pair<double, double> > v1;
    for (int i=0; i < x.size(); ++i) {
        v1.push_back(std::make_pair(x[i], y[i]));
    }
    // stable_sort(v1.begin(), v1.end(), less);
    stable_sort(v1.begin(), v1.end());
    for (int i=0; i < v1.size(); ++i) {
        x[i] = v1[i].first;
        y[i] = v1[i].second;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x27d00
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x86e0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x25eb7
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x27d90
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x27d90
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x27d50
movsd %xmm1, -0x88(%rbp)
movsd %xmm0, -0x80(%rbp)
jmp 0x25e67
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd %xmm1, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x27d20
jmp 0x25e8d
jmp 0x25e8f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x25e07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x27e90
jmp 0x25f99
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x27df0
movq -0x98(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x27e20
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x27db0
jmp 0x25eea
movl $0x0, -0x6c(%rbp)
movslq -0x6c(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x27e50
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x25f87
movslq -0x6c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x27e70
movsd (%rax), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
callq 0x27d90
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, (%rax)
movslq -0x6c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x27e70
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
callq 0x27d90
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x25ef1
leaq -0x30(%rbp), %rdi
callq 0x27e90
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::Interp1d(forrocket::interpolate::Interp1d const&)
forrocket::interpolate::Interp1d::Interp1d(const Interp1d& from) {
    x_src = from.x_src;
    y_src = from.y_src;
    fill_value = from.fill_value;

    if (typeid(*from.polator) == typeid(Linear1D)) {
        polator = new Linear1D();
    } else if (typeid(*from.polator) == typeid(CubicSpline1D)) {
        polator = new CubicSpline1D(from.x_src, from.y_src);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x76d0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x76d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27ef0
jmp 0x263e4
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x27ef0
jmp 0x263fb
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x26422
callq 0x64b0
jmp 0x26422
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0xbd41c(%rip), %rsi     # 0xe3850
callq 0x105f0
testb $0x1, %al
jne 0x2643f
jmp 0x2648a
movl $0x8, %edi
callq 0x6430
movq %rax, -0x48(%rbp)
jmp 0x2644f
movq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x6270
movq -0x48(%rbp), %rdi
callq 0x28170
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x26512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x26518
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x264a3
callq 0x64b0
jmp 0x264a3
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0xbd3b3(%rip), %rsi     # 0xe3868
callq 0x105f0
testb $0x1, %al
jne 0x264c0
jmp 0x26510
movl $0x30, %edi
callq 0x6430
movq %rax, -0x58(%rbp)
jmp 0x264d0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rsi, %rdx
addq $0x18, %rdx
callq 0x26eb0
jmp 0x264e6
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x26510
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x6440
jmp 0x26518
jmp 0x26512
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x7760
movq -0x28(%rbp), %rdi
callq 0x7760
movq -0x18(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::operator=(forrocket::interpolate::Interp1d const&)
forrocket::interpolate::Interp1d& forrocket::interpolate::Interp1d::operator=(const Interp1d& from) {
    if (this != &from) {
        x_src = from.x_src;
        y_src = from.y_src;
        fill_value = from.fill_value;

        if (typeid(*from.polator) == typeid(Linear1D)) {
            polator = new Linear1D();
        } else if (typeid(*from.polator) == typeid(CubicSpline1D)) {
            polator = new CubicSpline1D(from.x_src, from.y_src);
        }  
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x10(%rbp), %rax
je 0x26685
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27ef0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x27ef0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x265a9
callq 0x64b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0xbd295(%rip), %rsi     # 0xe3850
callq 0x105f0
testb $0x1, %al
jne 0x265c6
jmp 0x265fd
movl $0x8, %edi
callq 0x6430
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x6270
movq -0x38(%rbp), %rdi
callq 0x28170
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x26683
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x26614
callq 0x64b0
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0xbd242(%rip), %rsi     # 0xe3868
callq 0x105f0
testb $0x1, %al
jne 0x26631
jmp 0x26681
movl $0x30, %edi
callq 0x6430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, %rdx
addq $0x18, %rdx
callq 0x26eb0
jmp 0x26657
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x26681
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x6440
jmp 0x2668f
jmp 0x26683
jmp 0x26685
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6760
nopl (%rax,%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::operator()(std::vector<double, std::allocator<double>>)
std::vector<double> forrocket::interpolate::Interp1d::operator()(const std::vector<double> x) {
    std::vector<double> res;
    for(int i=0; i < x.size(); ++i) {
        res.push_back(polator->polate(x[i], x_src, y_src, fill_value));
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x76d0
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x86e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x267bd
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rdi
movq 0x38(%rax), %rax
movq %rax, -0x70(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x27ce0
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rsi
movq %rdx, %rcx
addq $0x18, %rcx
movq %rdx, %r8
addq $0x30, %r8
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movsd %xmm0, -0x68(%rbp)
jmp 0x2677d
movq -0x50(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x77e0
jmp 0x26796
jmp 0x26798
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2671b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7760
jmp 0x267da
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x267d0
movq -0x50(%rbp), %rdi
callq 0x7760
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::operator()(Eigen::Matrix<double, -1, 1, 0, -1, 1>)
Eigen::VectorXd forrocket::interpolate::Interp1d::operator()(const Eigen::VectorXd x) {
    Eigen::VectorXd res(x.size());
    for(int i=0; i < x.size(); ++i) {
        res[i] = polator->polate(x[i], x_src, y_src, fill_value);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x281b0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x281f0
movl $0x0, -0x2c(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x281b0
movq %rax, -0x68(%rbp)
jmp 0x2685d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
jge 0x26907
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x80(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0x28250
movq %rax, -0x78(%rbp)
jmp 0x2688d
movq -0x50(%rbp), %rdx
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq %rdx, %rcx
addq $0x18, %rcx
movq %rdx, %r8
addq $0x30, %r8
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movsd %xmm0, -0x88(%rbp)
jmp 0x268b9
movq -0x48(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x282e0
movq %rax, -0x90(%rbp)
jmp 0x268cf
movq -0x90(%rbp), %rax
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x26846
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x28370
jmp 0x26927
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2691a
movq -0x48(%rbp), %rdi
callq 0x28370
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6760
// File: sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::CubicSpline1D::~CubicSpline1D()
forrocket::interpolate::CubicSpline1D::~CubicSpline1D() {
    delete[] a_spline;
    delete[] b_spline;
    delete[] c_spline;
    delete[] d_spline;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xbc325(%rip), %rcx     # 0xe3820
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x27519
movq -0x10(%rbp), %rdi
callq 0x6560
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x27534
movq -0x20(%rbp), %rdi
callq 0x6560
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2754f
movq -0x28(%rbp), %rdi
callq 0x6560
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2756a
movq -0x30(%rbp), %rdi
callq 0x6560
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movsd 0x10(%rax), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x40, %rax
movq %rax, -0xb0(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x67f0
movq -0xb0(%rbp), %rsi
movsd %xmm0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x40(%rbp), %rdx
callq 0x2f2e0
movsd -0x18(%rbp), %xmm0
callq 0x6120
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x2f320
movq %rax, -0xa0(%rbp)
jmp 0x2d46f
movq -0xa0(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2f320
movq %rax, -0xc0(%rbp)
jmp 0x2d490
movsd -0x18(%rbp), %xmm0
callq 0x6120
movq -0xc0(%rbp), %rdi
movaps 0x681c8(%rip), %xmm1    # 0x95670
pxor %xmm1, %xmm0
movlpd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x2f320
movq %rax, -0xc8(%rbp)
jmp 0x2d4c3
movsd -0x18(%rbp), %xmm0
callq 0x67f0
movq -0xc8(%rbp), %rdi
movsd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x2f320
movq %rax, -0xd0(%rbp)
jmp 0x2d4eb
movq -0xd0(%rbp), %rdi
movq $0x0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x2f320
movq %rax, -0xd8(%rbp)
jmp 0x2d50c
movq -0xd8(%rbp), %rdi
movq $0x0, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x2f320
movq %rax, -0xe0(%rbp)
jmp 0x2d52d
movq -0xe0(%rbp), %rdi
movq $0x0, -0x88(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x2f320
movq %rax, -0xe8(%rbp)
jmp 0x2d554
movq -0xe8(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x2f320
jmp 0x2d57a
leaq -0x38(%rbp), %rdi
callq 0x2f490
movq -0xb8(%rbp), %rdi
addq $0x40, %rdi
callq 0x2f4c0
movq -0xb8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x40, %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
leaq -0x98(%rbp), %rsi
callq 0x2f4f0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f490
movq -0x50(%rbp), %rdi
callq 0x6760
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xa8(%rbp)
movq %rdi, %rax
movq -0xa8(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2f640
movsd (%rax), %xmm0
callq 0x7090
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movl $0x1, %esi
callq 0x2f640
movsd (%rax), %xmm0
callq 0x7090
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movl $0x2, %esi
callq 0x2f640
movq %rax, %rcx
movq -0x78(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x98(%rbp)
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x6120
movl $0x2, %edi
callq 0x283f0
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x6791b(%rip), %xmm1    # 0x95638
addsd %xmm1, %xmm0
callq 0x6370
movaps %xmm0, %xmm1
movsd -0x98(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x67f0
movaps %xmm0, %xmm1
movsd -0x90(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x67f0
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x50(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x67f0
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x6120
movq -0x78(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0x67857(%rip), %xmm2    # 0x95638
subsd 0x30(%rax), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x6120
movq -0x68(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x2f6d0
movq -0x58(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x98(%rbp)
movl $0x1, %edx
movq %rdx, -0x90(%rbp)
callq 0x2f7b0
movq -0x98(%rbp), %rdx
movq -0x88(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq %rdx, %rsi
callq 0x2f7b0
movsd -0xa0(%rbp), %xmm0
movsd (%rax), %xmm1
callq 0x60a0
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movl $0x2, %edx
movq %rdx, -0x80(%rbp)
callq 0x2f7b0
movsd (%rax), %xmm0
callq 0x66e0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movaps 0x668eb(%rip), %xmm1    # 0x95670
pxor %xmm1, %xmm0
movlpd %xmm0, -0x20(%rbp)
callq 0x2f7b0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq %rdx, %rsi
callq 0x2f7b0
movsd -0x78(%rbp), %xmm0
movsd (%rax), %xmm1
callq 0x60a0
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
callq 0x2f9d0
movq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x2f9f0
movq -0x68(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2fa30
movq %rax, -0x60(%rbp)
jmp 0x2edf3
movq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2fa30
jmp 0x2ee02
leaq -0x48(%rbp), %rdi
callq 0x2fba0
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fba0
movq -0x50(%rbp), %rdi
callq 0x6760
nopl (%rax)
// File: sus304[P]ForRocket/./lib/Eigen/src/Core/Dot.h
// Function: Eigen::MatrixBase<Eigen::Matrix<double, 4, 1, 0, 4, 1>>::normalize()
EIGEN_STRONG_INLINE void MatrixBase<Derived>::normalize()
{
  RealScalar z = squaredNorm();
  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
  if(z>RealScalar(0))
    derived() /= numext::sqrt(z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x32430
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2f9c6
leaq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movapd %xmm0, -0x20(%rbp)
movapd -0x20(%rbp), %xmm0
movapd %xmm0, -0x30(%rbp)
movapd -0x30(%rbp), %xmm0
sqrtpd %xmm0, %xmm0
movapd %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x32bc0
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x68(%rbp)
callq 0x32030
movq %rax, %rdi
leaq -0x68(%rbp), %rsi
callq 0x32470
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: sus304[P]ForRocket/src/environment/datetime.cpp
// Function: forrocket::DateTime::DateTime()
forrocket::DateTime::DateTime() {
    year = 2000;
    month = 1;
    day = 1;
    hour = 12;
    min = 0;
    sec = 0;
    msec = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x7d0, (%rax)          # imm = 0x7D0
movl $0x1, 0x4(%rax)
movl $0x1, 0x8(%rax)
movl $0xc, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x33fc2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rsi
addq $0x18, %rsi
movsd 0x38(%rax), %xmm0
leaq -0x24(%rbp), %rdi
callq 0x33fd0
movq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x34370
movq -0x30(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd (%rdi), %xmm0
callq 0x34420
movq -0x30(%rbp), %rdi
movsd %xmm0, 0x8(%rdi)
movsd (%rdi), %xmm0
callq 0x34440
movq -0x30(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl 0x4(%rax), %edx
imull $0x16f, %edi, %ecx      # imm = 0x16F
movl %edx, %esi
addl $0x9, %esi
movl $0xaaaaaaab, %r8d       # imm = 0xAAAAAAAB
imulq %r8, %rsi
shrq $0x23, %rsi
addl %esi, %edi
movl %edi, %esi
shll $0x3, %esi
subl %edi, %esi
shrl $0x2, %esi
subl %esi, %ecx
imull $0x113, %edx, %edx      # imm = 0x113
imulq $0x38e38e39, %rdx, %rdx # imm = 0x38E38E39
shrq $0x21, %rdx
addl %edx, %ecx
movl 0x8(%rax), %edx
addl %edx, %ecx
cvtsi2sd %rcx, %xmm0
movsd 0x62c5f(%rip), %xmm1    # 0x97030
addsd %xmm1, %xmm0
movl 0x14(%rax), %ecx
cvtsi2sd %rcx, %xmm1
movsd 0x62c53(%rip), %xmm2    # 0x97038
divsd %xmm2, %xmm1
movl 0x10(%rax), %ecx
cvtsi2sd %rcx, %xmm3
addsd %xmm3, %xmm1
divsd %xmm2, %xmm1
movl 0xc(%rax), %eax
cvtsi2sd %rax, %xmm2
addsd %xmm2, %xmm1
movsd 0x62c1b(%rip), %xmm2    # 0x97028
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x62c22(%rip), %xmm1    # 0x97080
subsd %xmm1, %xmm0
movsd 0x62c0e(%rip), %xmm1    # 0x97078
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x62be8(%rip), %xmm1    # 0x97068
mulsd %xmm1, %xmm0
movsd 0x62be4(%rip), %xmm1    # 0x97070
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movl $0x2, %edi
callq 0x283f0
movsd -0x38(%rbp), %xmm1
movsd 0x62baf(%rip), %xmm2    # 0x97060
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movl $0x3, %edi
callq 0x283f0
movsd -0x30(%rbp), %xmm1
movsd 0x62b7e(%rip), %xmm2    # 0x97058
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x62b4f(%rip), %xmm0    # 0x97048
movsd 0x62b4f(%rip), %xmm1    # 0x97050
callq 0x65c0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x33a20
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x33f60
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rdi)
callq 0x34300
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x33a20
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x33f60
movq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x40(%rdi)
callq 0x34300
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x76d0
movsd -0x10(%rbp), %xmm0
movsd 0x627c6(%rip), %xmm1    # 0x970e8
ucomisd %xmm1, %xmm0
jbe 0x34976
movsd -0x10(%rbp), %xmm0
movsd 0x626e3(%rip), %xmm1    # 0x97018
divsd %xmm1, %xmm0
leaq -0x30(%rbp), %rdi
callq 0x34a20
jmp 0x34944
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35830
leaq -0x30(%rbp), %rdi
callq 0x7760
jmp 0x349a8
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x7760
jmp 0x34a08
movsd -0x10(%rbp), %xmm0
movsd 0x62695(%rip), %xmm1    # 0x97018
divsd %xmm1, %xmm0
leaq -0x58(%rbp), %rdi
callq 0x35070
jmp 0x34992
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x35830
leaq -0x58(%rbp), %rdi
callq 0x7760
movq -0x70(%rbp), %rdi
movl $0x2, %esi
callq 0x27d90
movsd (%rax), %xmm0
movsd 0xafac6(%rip), %xmm1    # 0xe4488
divsd %xmm1, %xmm0
callq 0x6370
movq -0x70(%rbp), %rdi
movsd 0xafac9(%rip), %xmm1    # 0xe44a0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x77e0
jmp 0x349eb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x349fe
movq -0x70(%rbp), %rdi
callq 0x7760
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6760
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd %xmm6, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
subsd -0x8(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
subsd -0x8(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x600ff(%rip), %xmm0    # 0x95638
subsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x10(%rbp), %xmm2
movsd -0x48(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
subsd -0x8(%rbp), %xmm2
mulsd %xmm2, %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x40(%rbp), %xmm4
subsd -0x18(%rbp), %xmm4
movsd -0x48(%rbp), %xmm3
movsd -0x40(%rbp), %xmm5
subsd -0x30(%rbp), %xmm5
mulsd %xmm5, %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sus304[P]ForRocket/src/environment/air.cpp
// Function: forrocket::EnvironmentAir::EnvironmentAir(double)
forrocket::EnvironmentAir::EnvironmentAir(const double geometric_altitude) {
    auto res = standardatmosphere1976::Atmosphere(geometric_altitude);
    temprature = res[2];
    pressure = res[1];
    density = res[0];
    speed_of_sound = res[3];

    // double geopotential_height = geometric_altitude * wgs84.a / (wgs84.a + geometric_altitude);

    // int index_layer = 0;  // default layer
    // for (int i=0; i < height_array.size(); ++i) {
    //     if (geopotential_height < height_array[i]) {
    //         index_layer = i - 1;
    //         if (index_layer < 0) {
    //             index_layer = 0;
    //         }
    //         break;
    //     }
    //     else if (geopotential_height >= height_array.back()) {
    //         index_layer = 7;
    //         break;
    //     }
    // }

    // temprature = temperature_array[index_layer] + temperature_gradient_array[index_layer] * (geopotential_height - height_array[index_layer]);  // [K]
    // if (temperature_gradient_array[index_layer] == 0.0) {
    //     pressure = pressure_array[index_layer] * std::exp(g0 / R * (height_array[index_layer] - geopotential_height) / temperature_array[index_layer]);  // [Pa]
    // }
    // else {
    //     pressure = pressure_array[index_layer] * std::pow(temperature_array[index_layer] / temprature, g0 / R / temperature_gradient_array[index_layer]);
    // }
    // density = pressure / (R * temprature);  // [kg/m3]
    // speed_of_sound = std::sqrt(gamma * R * temprature);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x348f0
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x27d90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x27d90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x27d90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
leaq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x27d90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0x7760
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x170(%rbp)
movq %rdi, %rax
movq %rax, -0x178(%rbp)
callq 0x3bb50
movq -0x170(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x168(%rbp)
callq 0x3bb50
jmp 0x3602d
leaq -0xc0(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x3bbc0
jmp 0x3603e
movq -0x178(%rbp), %rdi
addq $0xa0, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3bfd0
jmp 0x3605a
leaq -0xc0(%rbp), %rdi
callq 0x365b0
leaq -0x160(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x3bbc0
jmp 0x36077
movq -0x178(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x3bfd0
jmp 0x3608c
leaq -0x160(%rbp), %rdi
callq 0x365b0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x360fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x360ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x365b0
jmp 0x360ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x365b0
movq -0x168(%rbp), %rdi
callq 0x365b0
movq -0x170(%rbp), %rdi
callq 0x365b0
movq -0x18(%rbp), %rdi
callq 0x6760