LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/codebrainz[P]libutfxx/utf/./utfstring.h
// Function: utf::string<char>& utf::string<char>::append<char const*>(char const*)
string& append(T str) {
		string_type tmp;
		utf::convert(str, tmp);
		s += tmp;
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2d44
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2130
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e70
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2040
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x2ec6
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ec9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20f0
jmp 0x2ec9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ee0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/img2pd/img2pd.cpp
// Function: AddImageToPixelDatabase(gaps::R2PixelDatabase&, char const*)
static int
AddImageToPixelDatabase(R2PixelDatabase& pd, const char *image_filename)
{
  // Add image to pixel database
  R2Image image;
  if (!image.ReadFile(image_filename)) return 0;
  pd.InsertImage(image_filename, image);

  // Increment image counter
  image_count++;

  // Print message
  if (print_debug) {
    printf("  %s\n", image_filename);
    fflush(stdout);
  }
  
  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x8f1c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8f40
testl %eax, %eax
je 0x6609
movq (%r14), %rax
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
incl 0x6ff1f(%rip)           # 0x764f8
movl $0x1, %ebp
cmpb $0x1, 0x6ff17(%rip)     # 0x764fc
jne 0x660b
leaq 0x4eb31(%rip), %rdi     # 0x5511f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movq 0x6f9a1(%rip), %rax     # 0x75fa0
movq (%rax), %rdi
callq 0x53a0
jmp 0x660b
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0x9498
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9498
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/EDDRSoftware[P]libdefsEval/main.cpp
// Function: fullPath(char const*, boost::filesystem::path const&, boost::filesystem::path*)
int fullPath(const char *pathIn, const path &base, path *outPath)
{
    int retVal = 0;


    try {

        *outPath = canonical(pathIn, base);

    } catch(const filesystem_error &error) {
        if(is_symlink(error.path1())) {
            cerr << "ERROR: Path " << error.path1() << " contains a broken symlink." <<
                 endl;
        } else {
            cerr << "ERROR: " << error.code().message() << " " << error.path1() << endl;
        }

        retVal = error.code().value();
    }

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x6daa
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x4100
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4350
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x47c0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47d9
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x480d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x480d
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x496f
movq %rbx, %rdi
callq 0x4120
movq %rax, %rbx
movq 0x40(%rax), %rsi
testq %rsi, %rsi
je 0x4831
addq $0x8, %rsi
jmp 0x4839
callq 0x4520
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x40c0
cmpl $0x4, -0x38(%rbp)
jne 0x4871
movq 0x979f(%rip), %rdi      # 0xdff0
leaq 0x57ac(%rip), %rsi      # 0xa004
movl $0xc, %edx
callq 0x4300
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x48d4
addq $0x8, %rsi
jmp 0x48dc
movq 0x9778(%rip), %rdi      # 0xdff0
leaq 0x57ae(%rip), %rsi      # 0xa02d
movl $0x7, %edx
callq 0x4300
movl 0x10(%rbx), %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x20(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x9747(%rip), %rdi      # 0xdff0
callq 0x4300
movq %rax, %r14
leaq 0x582b(%rip), %rsi      # 0xa0e3
movl $0x1, %edx
movq %rax, %rdi
callq 0x4300
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x4909
addq $0x8, %rsi
jmp 0x4911
callq 0x4520
movq %rax, %rsi
movq 0x970d(%rip), %rdi      # 0xdff0
callq 0x6d1e
movq %rax, %r14
leaq 0x571f(%rip), %rsi      # 0xa011
movl $0x1b, %edx
movq %rax, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4160
jmp 0x493a
callq 0x4520
movq %rax, %rsi
movq %r14, %rdi
callq 0x6d1e
movq %rax, %rdi
callq 0x4160
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x493a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
movl 0x10(%rbx), %ebx
callq 0x4430
jmp 0x47db
jmp 0x4967
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x496a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x496a
movq %rax, %rbx
callq 0x4430
movq %rbx, %rdi
callq 0x44a0
movq %rax, %rdi
callq 0x6d10
// File: /workspace/github_cpp_makefile_star2_O3/EDDRSoftware[P]libdefsEval/main.cpp
// Function: readUntilEOL(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void readUntilEOL(stringstream *stream, string *outVar)
{
    string buffer;

    getline(*stream, buffer);
    // getline does not trim the beginning of line.  There is usually whitespace.
    buffer.erase(buffer.begin(), find_if(buffer.begin(), buffer.end(),
                                         not1(ptr_fun<int, int>(isspace))));
    *outVar = buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %edx
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x44e0
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %rsi
addq %r14, %rsi
movq 0x926c(%rip), %rdx      # 0xdf90
movq %r14, %rdi
callq 0x7b12
movq -0x38(%rbp), %rcx
movq %r14, %rsi
subq %rcx, %rsi
movq -0x30(%rbp), %rdx
addq %rcx, %rdx
cmpq %rax, %rdx
je 0x4d53
subq %r14, %rax
leaq -0x38(%rbp), %rdi
movq %rax, %rdx
callq 0x4330
jmp 0x4d5b
movq %rsi, -0x30(%rbp)
movb $0x0, (%rcx,%rsi)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4190
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4d7c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d89
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4da1
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44a0
// File: /workspace/github_cpp_makefile_star2_O3/EDDRSoftware[P]libdefsEval/main.cpp
// Function: isRecursiveInclude(boost::filesystem::path const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
bool
isRecursiveInclude(const path &fp, std::vector<string> *pLibDefFiles)
{
    for (int i = 0; i < pLibDefFiles->size(); ++i)
    {
        if (fp.string().c_str() == (*pLibDefFiles)[i])
        {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rdi
cmpq %rdi, 0x8(%rsi)
je 0x5835
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rdi
callq 0x40b0
testl %eax, %eax
sete %al
je 0x5837
incq %r12
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x5807
jmp 0x5837
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, B*, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(B*&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(B*& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<Y>(i, e, cx)) // consume any white-spaces
                        return false;
                    if (cio::peek(i, e) == *Y::id::nil) // check/read null
                        return read_value<Y>(t, i, e, cx);
                    B_union p; // the union type that represents a B*
                        if (read_value<Y>(p, i, e, cx)) { // try reading it
                            if (p.d1) // let d1 != 0 indicates D1
                                return (t = alc::make_in_context<D1>(cx, p.d1)); // create and assign D1
                            // create and assign D2
                            return (t = alc::make_in_context<D2>(cx, std::move(p.d2)));
                        }
                        return false;
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x1c24(%rip), %rsi      # 0x4600
cmpq %rcx, %rax
je 0x29f2
movzbl (%rax), %edi
testb $0x8, (%rdi,%rsi)
je 0x29f2
incq %rax
movq %rax, (%rdx)
jmp 0x29dc
cmpq %rcx, %rax
je 0x29fc
cmpb $0x6e, (%rax)
je 0x29dc
leaq 0x20(%rsp), %r14
movl $0x0, -0x18(%r14)
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x4138(%rip), %rsi      # 0x6b58
leaq 0x8(%rsp), %rdi
callq 0x2af8
movl %eax, %ebp
testb %al, %al
je 0x2ac4
cmpl $0x0, 0x8(%rsp)
je 0x2a5f
movl $0x10, %edi
callq 0x2110
movl 0x8(%rsp), %ecx
movl $0x0, 0x8(%rax)
leaq 0x4141(%rip), %rdx      # 0x6b98
movq %rdx, (%rax)
movl %ecx, 0xc(%rax)
jmp 0x2ac1
movl $0x30, %edi
callq 0x2110
movl $0x1, 0x8(%rax)
leaq 0x4169(%rip), %rcx      # 0x6be0
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdx
cmpq %r14, %rdx
je 0x2a9e
movq %rdx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x2aa5
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r14, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ad3
callq 0x2100
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2af0
callq 0x2100
movq %rbx, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::write<cxon::JSON<cxon::json::format_traits>, B*, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, B const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(O& o, const B* t, Cx& cx) {
                    if (!t) // check/write null
                            return write_value<Y>(o, nullptr, cx);
                    // cast and write the runtime type
                    switch (t->type) {
                        case B::D1:
                            return write_value<Y>(o, static_cast<const D1*>(t), cx);
                        case B::D2:
                            return write_value<Y>(o, static_cast<const D2*>(t), cx);
                    }
                    return false;
                }

// Assembly:
testq %rsi, %rsi
je 0x393c
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x3b3c
testl %eax, %eax
je 0x3956
xorl %eax, %eax
retq
pushq %rax
leaq 0x8b2(%rip), %rsi       # 0x41f6
movl $0x4, %edx
callq 0x2040
movb $0x1, %al
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation(double, double)
Air Air::altitude_with_variation(double altitude, double input_percent){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density with altitude to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance(altitude, input_percent);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x5b4c
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x5ee6
addsd 0x1f1a4(%rip), %xmm0    # 0x25070
mulsd 0x118(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
Air Air::altitude_with_variation_table(double altitude, MatrixXd variation_table){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density table to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance_table(altitude, variation_table);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x5b4c
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x69e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a4e
leaq 0x8(%rsp), %rsi
movsd (%rsp), %xmm0
callq 0x62ca
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5460
movsd (%rsp), %xmm0
addsd 0x1eddb(%rip), %xmm0    # 0x25070
mulsd 0x118(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x62b4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x5460
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::coef_density_variance_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
double Air::coef_density_variance_table(double altitude, MatrixXd variation_table){
    // variation table : [altitude[m], air density variation[percent]
    vector<double> altitude_ref;
    vector<double> variation_ref;
    int len = variation_table.rows();

    altitude_ref.resize(len);
    variation_ref.resize(len);

    for(int i=0; i<len; i++){
        altitude_ref[i] = variation_table(i, 0);
        variation_ref[i] = variation_table(i, 1);
    }
    
    double percent_of_density_with_alt = linear_interp1_from_y(altitude, variation_ref, altitude_ref);

    return percent_of_density_with_alt / 100;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rsi), %r15
movslq %r15d, %r14
movq %r14, %rsi
callq 0x69ae
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x69ae
testl %r15d, %r15d
jle 0x6386
movq 0x8(%rbx), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %edi
cmovgq %rax, %rdi
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
shlq $0x3, %rax
cmpq %rsi, %rdi
je 0x6437
movq 0x10(%rbx), %r9
testq %r9, %r9
jle 0x6437
movq (%rbx), %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
cmpq $0x1, %r9
je 0x6437
addq %rax, %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %r15
jne 0x6342
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x692e
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x692e
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rbx
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
callq 0x64ad
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63d7
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x63ee
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6405
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x641c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movsd 0x8(%rsp), %xmm0
divsd 0x1ec4e(%rip), %xmm0    # 0x25078
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1f2cf(%rip), %rdi     # 0x2570d
leaq 0x1f2fd(%rip), %rsi     # 0x25742
leaq 0x1f322(%rip), %rcx     # 0x2576e
movl $0x151, %edx            # imm = 0x151
callq 0x5250
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x6477
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x6477
jmp 0x6474
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x648e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x64a5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: linear_interp1_from_y(double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
double linear_interp1_from_y(double y, vector<double> x_array, vector<double> y_array){
    // linear interpolattion with same number of x_array and y_array from y-axis
    // not extrapolation, It has the same value as the outermost point.
    // @params y: y component of the data you want to obtain
    // @params x_array The x component of the original data
    // @params y_array The x component of the original data
    // @return x(double) interpolated value
    double x = 0.0;
    double alpha = 0.0;
    for (int i = 0; i < y_array.size()-1; i++) {
        if (y >= y_array[i] && y < y_array[i+1]) {
            alpha = (y - y_array[i]) / (y_array[i+1] - y_array[i]);
            x = x_array[i] + alpha * (x_array[i+1] - x_array[i]);
        }
    }
    if (y < y_array[0]) {
        x = x_array[0];
    }else if (y >= y_array.back()){
        x = x_array.back();
    }
    return x;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorpd %xmm1, %xmm1
cmpq $0x1, %rdx
je 0x6518
movl $0x1, %esi
movsd -0x8(%rcx,%rsi,8), %xmm2
ucomisd %xmm2, %xmm0
jb 0x6510
movsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x6510
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
subsd %xmm2, %xmm3
divsd %xmm3, %xmm4
movq (%rdi), %r8
movsd -0x8(%r8,%rsi,8), %xmm2
movsd (%r8,%rsi,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
incq %rsi
cmpq %rsi, %rdx
jne 0x64cd
movsd (%rcx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x6527
movq (%rdi), %rax
jmp 0x6536
ucomisd -0x8(%rax), %xmm0
jb 0x653a
movq 0x8(%rdi), %rax
addq $-0x8, %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
      m_cols = nbCols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x6bfc
movq %rsi, %r12
movq (%r15), %rdi
callq 0x5460
testq %r12, %r12
je 0x6bf7
movq %r12, %rax
shrq $0x3d, %rax
jne 0x6bc9
shlq $0x3, %r12
movq %r12, %rdi
callq 0x54d0
testq %rax, %rax
jne 0x6bf9
movl $0x8, %edi
callq 0x51e0
movq 0x2b3be(%rip), %rcx     # 0x31f98
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2b3d0(%rip), %rsi     # 0x31fb8
movq 0x2b391(%rip), %rdx     # 0x31f80
movq %rax, %rdi
callq 0x5620
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::quatNAVI2BODY(double)
Quaterniond RocketStage::quatNAVI2BODY(double t){
    Quaterniond quatNAVI2BODY_, quat_drift_NAVI2BODY_;

    double gyro_bias_abs = this->gyro_bias.norm();
    if (gyro_bias_abs != 0.0) {
        Vector3d gyro_bias_direction = this->gyro_bias / gyro_bias_abs;
        quat_drift_NAVI2BODY_ = Quaterniond(AngleAxisd(gyro_bias_abs * t, gyro_bias_direction));
    } else {
        quat_drift_NAVI2BODY_ = Quaterniond::Identity();
    }

    quatNAVI2BODY_ = this->quat_offset_NAVI2BODY * quat_drift_NAVI2BODY_;
    return quatNAVI2BODY_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movapd 0x630(%rsi), %xmm4
movapd %xmm4, %xmm5
mulpd %xmm4, %xmm5
movsd 0x640(%rsi), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
addsd %xmm1, %xmm2
addsd %xmm5, %xmm2
sqrtsd %xmm2, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x13b51
jnp 0x13bb4
movapd %xmm2, %xmm1
unpcklpd %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
divpd %xmm1, %xmm4
movapd %xmm4, 0x20(%rsp)
divsd %xmm2, %xmm3
movapd %xmm3, 0x30(%rsp)
mulsd %xmm2, %xmm0
mulsd 0x121a7(%rip), %xmm0    # 0x25d20
movsd %xmm0, 0x8(%rsp)
callq 0x5690
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50f0
movapd 0x30(%rsp), %xmm8
mulsd %xmm0, %xmm8
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd 0x20(%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm8       # xmm8 = xmm8[0],mem[0]
jmp 0x13bc6
xorpd %xmm0, %xmm0
xorpd %xmm8, %xmm8
movhpd 0x114aa(%rip), %xmm8    # xmm8 = xmm8[0],mem[0]
movapd 0x610(%r14), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movupd 0x618(%r14), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
movapd 0x620(%r14), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movupd 0x628(%r14), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd %xmm0, %xmm5
mulpd %xmm2, %xmm5
movapd %xmm8, %xmm6
mulpd %xmm4, %xmm6
addpd %xmm5, %xmm6
movapd %xmm0, %xmm5
mulpd %xmm3, %xmm5
movapd %xmm8, %xmm7
mulpd %xmm1, %xmm7
subpd %xmm7, %xmm5
pshufd $0x4e, %xmm5, %xmm5     # xmm5 = xmm5[2,3,0,1]
movq 0x1232f(%rip), %xmm7    # 0x25f60
pxor %xmm7, %xmm5
addpd %xmm6, %xmm5
mulpd %xmm8, %xmm2
mulpd %xmm0, %xmm4
subpd %xmm4, %xmm2
mulpd %xmm8, %xmm3
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
pshufd $0x4e, %xmm1, %xmm0     # xmm0 = xmm1[2,3,0,1]
pxor %xmm7, %xmm0
subpd %xmm0, %xmm2
movapd %xmm5, (%rbx)
movapd %xmm2, 0x10(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::progress(double)
void RocketStage::progress(double time_now){
    double time_total = calc_end_time;
    cout << fixed << setprecision(0);
    cout << time_now << "sec / " << time_total << "sec\t@Stage " << num_stage << "\r" << flush;
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x260(%rdi), %xmm1
movsd %xmm1, (%rsp)
movq 0x1e321(%rip), %rdi     # 0x31fb0
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rdi,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
movq $0x0, 0x8(%rdi,%rax)
callq 0x5570
movq %rax, %r14
leaq 0x12db1(%rip), %rsi     # 0x26a73
movl $0x6, %edx
movq %rax, %rdi
callq 0x5430
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x5570
movq %rax, %r14
leaq 0x12d94(%rip), %rsi     # 0x26a7a
movl $0xb, %edx
movq %rax, %rdi
callq 0x5430
movl 0x250(%rbx), %esi
movq %r14, %rdi
callq 0x5630
movq %rax, %rbx
leaq 0x12c25(%rip), %rsi     # 0x26930
movl $0x1, %edx
movq %rax, %rdi
callq 0x5430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5270
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: operator>>(std::istream&, picojson::value&)
inline std::istream& operator>>(std::istream& is, picojson::value& x)
{
  picojson::set_last_error(std::string());
  std::string err = picojson::parse(x, is);
  if (! err.empty()) {
    picojson::set_last_error(err);
    is.setstate(std::ios::failbit);
  }
  return is;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x1d0d3(%rip), %rdi     # 0x323f0
leaq 0x8(%rsp), %rsi
callq 0x5220
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1533e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
leaq 0x8(%rsp), %rcx
movq %r15, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movb $0x0, 0x10(%rcx)
movq (%rbx), %rdx
movq -0x18(%rdx), %rdx
movq 0xe8(%rbx,%rdx), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, (%rsi)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %edi, 0x8(%rsi)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movl %edi, 0x8(%rdx)
leaq 0x28(%rsp), %rdi
movq %r14, (%rdi)
callq 0x166bc
cmpq $0x0, 0x10(%rsp)
je 0x153b7
leaq 0x1d05a(%rip), %rdi     # 0x323f0
leaq 0x8(%rsp), %rsi
callq 0x5220
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x4, %esi
callq 0x55f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x153ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x153df
jmp 0x153df
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x153f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::~value()
inline value::~value() {
    switch (type_) {
#define DEINIT(p) case p##type: delete u_.p; break
      DEINIT(string_);
      DEINIT(array_);
      DEINIT(object_);
#undef DEINIT
    default: break;
    }
  }

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x154ff
cmpl $0x4, %eax
je 0x154e7
cmpl $0x3, %eax
jne 0x1551e
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x154e0
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x154e0
movq (%rax), %rsi
incq %rsi
callq 0x53b0
movl $0x20, %esi
jmp 0x15515
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x154f8
movq %rbx, %rdi
callq 0x7568
movl $0x18, %esi
jmp 0x15515
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x15510
movq %rbx, %rdi
callq 0x7470
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x53b0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/rocket.hpp
// Function: CsvObserver::CsvObserver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CsvObserver(const std::string& FileName, bool isAddition = false){
        if (isAddition == false){ // 追加書き込みモードかどうか
            fout.open(FileName, std::ios_base::out);
            fout << header << std::endl;
        } else {
            fout.open(FileName, std::ios_base::out | std::ios_base::app); // 追加書き込みモード
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x183b4
leaq 0x1b8df(%rip), %rax     # 0x31630
movq %rax, (%rbx)
leaq 0xec0(%rbx), %r14
movq %r14, %rdi
callq 0x5600
leaq 0x10c0(%rbx), %r15
leaq 0x10d0(%rbx), %r13
movq %r13, 0x10c0(%rbx)
leaq 0x10ea0(%rip), %rsi     # 0x26c1f
leaq 0x1128a(%rip), %rdx     # 0x27010
movq %r15, %rdi
callq 0x76ba
testb %bpl, %bpl
je 0x15da5
movq %r14, %rdi
movq %r12, %rsi
movl $0x11, %edx
callq 0x51c0
jmp 0x15df5
movq %r14, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x51c0
movq 0x10c0(%rbx), %rsi
movq 0x10c8(%rbx), %rdx
movq %r14, %rdi
callq 0x5430
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5270
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x15e25
movq %rax, %r12
jmp 0x15e2d
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x15e25
movq (%r13), %rsi
incq %rsi
callq 0x53b0
movq %r14, %rdi
callq 0x5510
movq %rbx, %rdi
callq 0x7282
movq %r12, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: std::istreambuf_iterator<char, std::char_traits<char>> picojson::_parse<picojson::default_parse_context, std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::default_parse_context&, std::istreambuf_iterator<char, std::char_traits<char>> const&, std::istreambuf_iterator<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) {
    input<Iter> in(first, last);
    if (! _parse(ctx, in) && err != NULL) {
      char buf[64];
      SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
      *err = buf;
      while (1) {
	int ch = in.getc();
	if (ch == -1 || ch == '\n') {
	  break;
	} else if (ch >= ' ') {
	  err->push_back(ch);
	}
      }
    }
    return in.cur();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups (%rdx), %xmm0
movaps %xmm0, 0x10(%rsi)
movb $0x0, 0x20(%rsi)
movl $0x1, 0x24(%rsi)
callq 0x1679c
testq %rbx, %rbx
je 0x16758
testb %al, %al
jne 0x16758
movq %rsp, %r14
movl 0x24(%r14), %ecx
leaq 0x10387(%rip), %rdx     # 0x26a88
leaq 0x30(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x5560
movq 0x8(%rbx), %r12
movq %r15, %rdi
callq 0x51a0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x5540
movq %r14, %rdi
callq 0x16b16
cmpl $-0x1, %eax
je 0x16758
cmpl $0xa, %eax
je 0x16758
cmpl $0x20, %eax
jl 0x16734
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5330
jmp 0x16734
cmpb $0x0, 0x20(%rsp)
je 0x16780
movb $0x0, 0x20(%rsp)
movq (%rsp), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x16794
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x16784
movl 0x8(%rsp), %edx
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x16779
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::getc()
int getc() {
      if (consumed_) {
        if (*cur_ == '\n') {
          ++line_;
        }
        ++cur_;
      }
      if (cur_ == end_) {
        consumed_ = false;
        return -1;
      }
      consumed_ = true;
      return *cur_ & 0xff;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x16b4d
movq %rbx, %rdi
callq 0x17b90
cmpb $0xa, %al
jne 0x16b32
incl 0x24(%rbx)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x16b92
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
leaq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x17b90
cmpl $-0x1, %eax
sete %bpl
movq %r14, %rdi
callq 0x17b90
cmpl $-0x1, %eax
setne %al
cmpb %al, %bpl
je 0x16b7e
movb $0x0, 0x20(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x16b8d
movb $0x1, 0x20(%rbx)
movq %rbx, %rdi
callq 0x17b90
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x16b46
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_object<picojson::default_parse_context, std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::default_parse_context&, picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline bool _parse_object(Context& ctx, input<Iter>& in) {
    if (! ctx.parse_object_start()) {
      return false;
    }
    if (in.expect('}')) {
      return true;
    }
    do {
      std::string key;
      if (! in.expect('"')
	  || ! _parse_string(key, in)
	  || ! in.expect(':')) {
	return false;
      }
      if (! ctx.parse_object_item(in, key)) {
	return false;
      }
    } while (in.expect(','));
    return in.expect('}');
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1767c
testb %al, %al
je 0x16e86
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x172a6
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x16e88
leaq 0x10(%rsp), %r12
movq %rsp, %r15
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x22, %esi
callq 0x172a6
testb %al, %al
je 0x16e45
movq %r15, %rdi
movq %rbx, %rsi
callq 0x16fa0
testb %al, %al
je 0x16e45
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x172a6
testb %al, %al
je 0x16e45
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1772c
movl %eax, %ebp
jmp 0x16e47
xorl %ebp, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16e5d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
testb %bpl, %bpl
je 0x16e86
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x172a6
testb %al, %al
jne 0x16df0
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x172a6
jmp 0x16e88
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16eae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::istreambuf_iterator<char, std::char_traits<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline bool _parse_string(String& out, input<Iter>& in) {
    while (1) {
      int ch = in.getc();
      if (ch < ' ') {
	in.ungetc();
	return false;
      } else if (ch == '"') {
	return true;
      } else if (ch == '\\') {
	if ((ch = in.getc()) == -1) {
	  return false;
	}
	switch (ch) {
#define MAP(sym, val) case sym: out.push_back(val); break
	  MAP('"', '\"');
	  MAP('\\', '\\');
	  MAP('/', '/');
	  MAP('b', '\b');
	  MAP('f', '\f');
	  MAP('n', '\n');
	  MAP('r', '\r');
	  MAP('t', '\t');
#undef MAP
	case 'u':
	  if (! _parse_codepoint(out, in)) {
	    return false;
	  }
	  break;
	default:
	  return false;
	}
      } else {
	out.push_back(ch);
      }
    }
    return false;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x16b16
cmpl $0x20, %eax
jge 0x16fc4
movb $0x0, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf135(%rip), %r15      # 0x26100
cmpl $0x5c, %eax
je 0x16ff3
cmpl $0x22, %eax
je 0x1706b
movsbl %al, %esi
movq %r14, %rdi
callq 0x5330
movq %rbx, %rdi
callq 0x16b16
cmpl $0x20, %eax
jge 0x16fcb
jmp 0x16fb8
movq %rbx, %rdi
callq 0x16b16
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x61, %ecx
jg 0x17017
cmpl $0x22, %ecx
je 0x17030
cmpl $0x2f, %ecx
je 0x1702c
cmpl $0x5c, %ecx
jne 0x16fbe
movb $0x5c, %al
jmp 0x16fd9
leal -0x6e(%rcx), %edx
cmpl $0x7, %edx
ja 0x17034
movslq (%r15,%rdx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movb $0xa, %al
jmp 0x16fd9
movb $0x2f, %al
jmp 0x16fd9
movb $0x22, %al
jmp 0x16fd9
cmpl $0x62, %ecx
je 0x17064
cmpl $0x66, %ecx
jne 0x16fbe
movb $0xc, %al
jmp 0x16fd9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17072
testb %al, %al
jne 0x16fe4
jmp 0x16fbc
movb $0x9, %al
jmp 0x16fd9
movb $0xd, %al
jmp 0x16fd9
movb $0x8, %al
jmp 0x16fd9
movb $0x1, %al
jmp 0x16fbe
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::expect(int)
bool expect(int expect) {
      skip_ws();
      if (getc() != expect) {
	ungetc();
	return false;
      }
      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movabsq $0x100002600, %r15      # imm = 0x100002600
movq %r14, %rdi
callq 0x16b16
cmpl $0x20, %eax
ja 0x172cf
movl %eax, %eax
btq %rax, %r15
jb 0x172ba
movb $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x16b16
cmpl %ebx, %eax
je 0x172e5
movb $0x0, 0x20(%r14)
cmpl %ebx, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::default_parse_context::parse_array_item<std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&, unsigned long)
bool parse_array_item(input<Iter>& in, size_t) {
      array& a = out_->get<array>();
      a.push_back(value());
      default_parse_context ctx(&a.back());
      return _parse(ctx, in);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
cmpl $0x4, (%rax)
jne 0x173af
movq %rsi, %rbx
movq 0x8(%rax), %r14
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x17402
movl (%rsp), %eax
cmpl $0x5, %eax
je 0x17370
cmpl $0x4, %eax
je 0x17357
cmpl $0x3, %eax
jne 0x1738f
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x17350
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x17350
movq (%rax), %rsi
incq %rsi
callq 0x53b0
movl $0x20, %esi
jmp 0x17387
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x17369
movq %r15, %rdi
callq 0x7568
movl $0x18, %esi
jmp 0x17387
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x17382
movq %r15, %rdi
callq 0x7470
movl $0x30, %esi
movq %r15, %rdi
callq 0x53b0
movq 0x8(%r14), %rax
addq $-0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x1679c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0xf7d7(%rip), %rsi      # 0x26b9a
movq %rax, %rdi
callq 0x5180
movq 0x1ac1e(%rip), %rsi     # 0x31ff0
movq 0x1abc7(%rip), %rdx     # 0x31fa0
movq %rbx, %rdi
callq 0x5620
movq %rax, %r14
movq %rbx, %rdi
callq 0x52a0
jmp 0x173f9
movq %rax, %r14
movq %rsp, %rdi
callq 0x154ae
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::value(picojson::value const&)
inline value::value(const value& x) : type_(x.type_) {
    switch (type_) {
#define INIT(p, v) case p##type: u_.p = v; break
      INIT(string_, new std::string(*x.u_.string_));
      INIT(array_, new array(*x.u_.array_));
      INIT(object_, new object(*x.u_.object_));
#undef INIT
    default:
      u_ = x.u_;
      break;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
cmpl $0x5, %eax
je 0x17f01
cmpl $0x4, %eax
je 0x17ee6
cmpl $0x3, %eax
jne 0x17f20
movl $0x20, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rax
leaq 0x10(%r15), %rcx
movq %rcx, (%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x7624
jmp 0x17f1a
movl $0x18, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x17f5a
jmp 0x17f1a
movl $0x30, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x17c42
movq %r15, 0x8(%rbx)
jmp 0x17f28
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
jmp 0x17f4a
movq %rax, %rbx
movl $0x30, %esi
jmp 0x17f4a
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/integrate/max_step_checker.hpp
// Function: boost::numeric::odeint::failed_step_checker::operator()()
void operator()(void)
    {
        if( m_steps++ >= m_max_steps )
        {
            char error_msg[200];
            sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
            BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) );
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl %edx, %eax
jge 0x19ca4
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd8a7(%rip), %rsi      # 0x27552
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50e0
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rbx, %rdi
callq 0x51a0
leaq (%rsp,%rax), %rdx
addq $0x50, %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76ba
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x54a0
leaq 0x17ab1(%rip), %rax     # 0x317a8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xd893(%rip), %rax      # 0x27599
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xd8ba(%rip), %rax      # 0x275cf
movq %rax, 0x8(%rsi)
movq $0x69, 0x10(%rsi)
callq 0x1a502
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5400
jmp 0x19d38
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19d4f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
// Function: double boost::numeric::odeint::default_error_checker<double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::error<std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, double>(boost::numeric::odeint::array_algebra&, std::array<double, 14ul> const&, std::array<double, 14ul> const&, std::array<double, 14ul>&, double) const
value_type error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const
    {
        using std::abs;
        // this overwrites x_err !
        algebra.for_each3( x_err , x_old , dxdt_old ,
                typename operations_type::template rel_error< value_type >( m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt * abs(get_unit_value( dt )) ) );

        // value_type res = algebra.reduce( x_err ,
        //        typename operations_type::template maximum< value_type >() , static_cast< value_type >( 0 ) );
        return algebra.norm_inf( x_err );
    }

// Assembly:
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
andpd 0xb224(%rip), %xmm0     # 0x25030
mulsd 0x18(%rdi), %xmm0
xorl %eax, %eax
movapd 0xb215(%rip), %xmm4     # 0x25030
movsd (%r8,%rax,8), %xmm5
andpd %xmm4, %xmm5
movsd (%rdx,%rax,8), %xmm6
andpd %xmm4, %xmm6
movsd (%rcx,%rax,8), %xmm7
andpd %xmm4, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm3, %xmm6
addsd %xmm7, %xmm6
mulsd %xmm2, %xmm6
addsd %xmm1, %xmm6
divsd %xmm6, %xmm5
movsd %xmm5, (%r8,%rax,8)
incq %rax
cmpq $0xe, %rax
jne 0x19e1b
xorpd %xmm0, %xmm0
xorl %eax, %eax
movapd 0xb1c4(%rip), %xmm1     # 0x25030
movapd %xmm0, %xmm2
movsd (%r8,%rax,8), %xmm0
andpd %xmm1, %xmm0
maxsd %xmm2, %xmm0
incq %rax
cmpq $0xe, %rax
jne 0x19e6c
retq
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/fileio.cpp
// Function: interp_matrix(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, int)
double interp_matrix(double x, MatrixXd matrix, int col_num){
    // 線形補間をする、外挿は無し。点の外は最外点そのまま
    // (x, y)の行が沢山並んでいるのを想定
    // @params x 取得したいデータのx成分
    // @params matrix 2x? データ配列(x,y)
    // @params col_num 取得したいデータの列数 default:1
    // @return y(double) 入力xのデータ
    double y = 0.0;
    double alpha = 0.0;
    for (int i = 0; i < matrix.rows()-1; i++) {
        if (x >= matrix(i,0) && x < matrix(i+1,0)) {
            alpha = (x - matrix(i,0)) / (matrix(i+1,0) - matrix(i,0));
            y = matrix(i,col_num) + alpha * (matrix(i+1,col_num) - matrix(i,col_num));
        }
    }
    if (x < matrix(0,0)) {
        y = matrix(0,col_num);
    }else if (x >= matrix(matrix.rows()-1,0)){
        y = matrix(matrix.rows()-1,col_num);
    }
    return y;
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
xorpd %xmm1, %xmm1
cmpq $0x2, %rax
jl 0x1aa30
movq 0x10(%rdi), %r9
movslq %esi, %r8
testl %r8d, %r8d
setns %cl
cmpq %r8, %r9
seta %dl
testq %r9, %r9
jle 0x1aa8f
andb %dl, %cl
imulq %rax, %r8
movq (%rdi), %rdx
leaq (%rdx,%r8,8), %r8
movl $0x1, %r9d
movsd -0x8(%rdx,%r9,8), %xmm2
ucomisd %xmm2, %xmm0
jb 0x1aa28
movsd (%rdx,%r9,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x1aa28
testb %cl, %cl
je 0x1aa8f
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
subsd %xmm2, %xmm3
divsd %xmm3, %xmm4
movsd -0x8(%r8,%r9,8), %xmm2
movsd (%r8,%r9,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
incq %r9
cmpq %r9, %rax
jne 0x1a9de
testq %rax, %rax
jle 0x1aa8f
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
jle 0x1aa8f
movq (%rdi), %rcx
movsd (%rcx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x1aa61
testl %esi, %esi
js 0x1aa8f
movslq %esi, %rsi
cmpq %rsi, %rdx
jbe 0x1aa8f
imulq %rsi, %rax
leaq (%rcx,%rax,8), %rax
jmp 0x1aa85
ucomisd -0x8(%rcx,%rax,8), %xmm0
jb 0x1aa89
testl %esi, %esi
js 0x1aa8f
movslq %esi, %rsi
cmpq %rsi, %rdx
jbe 0x1aa8f
leaq -0x1(%rax), %rdx
imulq %rax, %rsi
leaq (%rcx,%rsi,8), %rax
leaq (%rax,%rdx,8), %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
leaq 0xac77(%rip), %rdi      # 0x2570d
leaq 0xaca5(%rip), %rsi      # 0x25742
leaq 0xacca(%rip), %rcx      # 0x2576e
movl $0x151, %edx            # imm = 0x151
callq 0x5250
// File: /workspace/github_cpp_makefile_star2_O3/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: bool io::CSVReader<2u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::read_row<double, double>(double&, double&)
bool read_row(ColType& ...cols){
                        static_assert(sizeof...(ColType)>=column_count,
                                "not enough columns specified");
                        static_assert(sizeof...(ColType)<=column_count,
                                "too many columns specified");
                        try{
                                try{
       
                                        char*line;
                                        do{
                                                line = in.next_line();
                                                if(!line)
                                                        return false;
                                        }while(comment_policy::is_comment(line));
                                       
                                        detail::parse_line<trim_policy, quote_policy>
                                                (line, row, col_order);
               
                                        parse_helper(0, cols...);
                                }catch(error::with_file_name&err){
                                        err.set_file_name(in.get_truncated_file_name());
                                        throw;
                                }
                        }catch(error::with_file_line&err){
                                err.set_file_line(in.get_file_line());
                                throw;
                        }

                        return true;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1d940
movq %rax, %r12
testq %rax, %rax
je 0x1bd24
leaq 0x1d0(%rbx), %rsi
leaq 0x220(%rbx), %rdx
movq %r12, %rdi
callq 0x1e2fc
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1e458
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x1bd7b
movq %r14, %rdi
callq 0x5190
movq %rax, %r14
leaq 0xc8(%rbx), %rsi
movl $0xff, %edx
movq %rax, %rdi
callq 0x5200
movb $0x0, 0xff(%r14)
callq 0x54f0
jmp 0x1bd96
movq %rdx, %r15
movq %rax, %r14
callq 0x55a0
cmpl $0x1, %r15d
jne 0x1bd9e
movq %r14, %rdi
callq 0x5190
movl 0x1c8(%rbx), %ecx
movl %ecx, (%rax)
callq 0x54f0
movq %rax, %r14
callq 0x55a0
movq %r14, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x722d