LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::windows_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name)
    {
      return name.size() != 0
        && name[0] != ' '
        && name.find_first_of(windows_invalid_chars) == std::string::npos
        && *(name.end()-1) != ' '
        && (*(name.end()-1) != '.'
          || name.length() == 1 || name == "..");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2bbd8
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x20, (%rax)
jne 0x2bbdd
xorl %r14d, %r14d
jmp 0x2bbfe
movq 0x20a7c(%rip), %rsi     # 0x4c660
movq 0x20a7d(%rip), %rcx     # 0x4c668
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb6c0
cmpq $-0x1, %rax
je 0x2bc06
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movzbl -0x1(%rcx,%rax), %ecx
cmpl $0x20, %ecx
je 0x2bbd8
movb $0x1, %r14b
cmpl $0x2e, %ecx
jne 0x2bbfe
cmpq $0x1, %rax
je 0x2bbfe
leaq 0xaac0(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
sete %r14b
jmp 0x2bbfe
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name)
    {
      return
        name.size() != 0
        && (name == "."
          || name == ".."
          || (windows_name(name)
            && portable_posix_name(name)
            && name[0] != '.' && name[0] != '-'));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2bcb9
movq %rdi, %rbx
leaq 0xaa99(%rip), %rsi      # 0x366ed
callq 0xb110
movb $0x1, %r14b
testl %eax, %eax
je 0x2bcbc
leaq 0xaa85(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2bcbc
movq %rbx, %rdi
callq 0x2bbbf
xorl %r14d, %r14d
testb %al, %al
je 0x2bcbc
cmpq $0x0, 0x8(%rbx)
je 0x2bcbc
movq 0x209f0(%rip), %rsi     # 0x4c680
movq 0x209f1(%rip), %rcx     # 0x4c688
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb7a0
cmpq $-0x1, %rax
jne 0x2bcbc
movq (%rbx), %rax
movb (%rax), %al
addb $-0x2f, %al
cmpb $-0x2, %al
setb %r14b
jmp 0x2bcbc
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_directory_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name)
    {
      return
        name == "."
        || name == ".."
        || (portable_name(name)
          && name.find('.') == std::string::npos);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xaa18(%rip), %rsi      # 0x366ed
callq 0xb110
movb $0x1, %r14b
testl %eax, %eax
je 0x2bd1c
leaq 0xaa04(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2bd1c
movq %rbx, %rdi
callq 0x2bc3c
testb %al, %al
je 0x2bd19
movq %rbx, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
sete %r14b
jmp 0x2bd1c
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/portability.cpp
// Function: boost::filesystem::portable_file_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name)
    {
      std::string::size_type pos;
      return
         portable_name(name)
         && name != "."
         && name != ".."
         && ((pos = name.find('.')) == std::string::npos
             || (name.find('.', pos+1) == std::string::npos
               && (pos + 5) > name.length()))
        ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2bc3c
testb %al, %al
je 0x2bd8c
leaq 0xa9af(%rip), %rsi      # 0x366ed
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2bd8c
leaq 0xa99b(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2bd8c
movq %rbx, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
je 0x2bd93
movq %rax, %r14
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0xb5c0
cmpq $-0x1, %rax
je 0x2bd97
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x2bd8e
addq $0x5, %r14
cmpq 0x8(%rbx), %r14
seta %al
jmp 0x2bd8e
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./libs/filesystem/src/unique_path.cpp
// Function: (anonymous namespace)::fail(int, boost::system::error_code*)
void fail(int err, boost::system::error_code* ec)
{
  if (ec == 0)
    BOOST_FILESYSTEM_THROW( boost::system::system_error(err,
      boost::system::system_category(),
      "boost::filesystem::unique_path"));

  ec->assign(err, boost::system::system_category());
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
testq %rsi, %rsi
je 0x2bf7d
movq %rsi, %rbx
callq 0x2c4e2
movl %r14d, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x40, %edi
callq 0xb250
movq %rax, %rbx
callq 0x2c4e2
leaq 0xab4c(%rip), %rcx      # 0x36ae2
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x2bb18
leaq 0x1f5a5(%rip), %rsi     # 0x4b550
leaq -0x2846(%rip), %rdx     # 0x2976c
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/filesystem/path.hpp
// Function: boost::filesystem::path::wstring[abi:cxx11]() const
const std::wstring  wstring() const
    {
      std::wstring tmp;
      if (!m_pathname.empty())
        path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
          tmp);
      return tmp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x2c017
movq (%rsi), %r15
callq 0x2b49e
addq %r15, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2b7a8
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2c033
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./command.hpp
// Function: command::add_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void (boost::program_options::options_description&)>)
void add_subcommand(CommandNameT command_name,
        CommandDescT command_desc,
        CommandCallbackT callback) {
    auto& callback_map = global_command_map();
    callback_map[std::move(command_name)] = std::make_tuple(
            std::move(command_desc),
            std::move(callback));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb 0x20082(%rip), %al      # 0x4c748
testb %al, %al
je 0x2c7a3
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq 0x18(%r15), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x2c702
movups (%r15), %xmm1
addq $0x10, %r15
movaps %xmm1, -0x60(%rbp)
movq %rax, -0x50(%rbp)
movups %xmm0, (%r15)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rcx
leaq 0x10(%r14), %rax
cmpq %rax, %rcx
je 0x2c723
movq %rcx, -0x40(%rbp)
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
jmp 0x2c72a
movups (%rax), %xmm0
movups %xmm0, (%r15)
movq 0x8(%r14), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x1ffcf(%rip), %rdi     # 0x4c718
movq %rbx, %rsi
callq 0x2e014
movq %rax, %rbx
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0xb560
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e9c8
movq 0x20(%r14), %rdi
cmpq %r15, %rdi
je 0x2c781
callq 0xb430
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x2c798
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xbcbf
jmp 0x2c6ce
movq %rax, %rdi
callq 0xe915
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2e094
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./subprocess.hpp
// Function: subprocess::run_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
ExitStatusT run_cmd(const std::string& cmd, bool require_stdout=true) {
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe) {
        return -1;
    }
    constexpr int buffer_size = 128;
    char buffer[buffer_size];
    while (!feof(pipe)) {
        if (fgets(buffer, buffer_size, pipe) != nullptr) {
            if (require_stdout) {
                printf("%s", buffer);
            }
        }
    }
    return pclose(pipe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebx
movq (%rdi), %rdi
leaq 0x9d36(%rip), %rsi      # 0x36f4b
callq 0xb150
testq %rax, %rax
je 0x2d27c
movq %rax, %r14
movq %rax, %rdi
callq 0xb700
testl %eax, %eax
jne 0x2d272
leaq -0xa0(%rbp), %r15
xorb $0x1, %bl
leaq 0x9cb8(%rip), %r12      # 0x36ef7
movq %r15, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0xb720
testq %rax, %rax
sete %al
orb %bl, %al
jne 0x2d266
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r14, %rdi
callq 0xb700
testl %eax, %eax
je 0x2d23f
movq %r14, %rdi
callq 0xb620
jmp 0x2d281
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: boost::program_options::basic_command_line_parser<char>::run()
basic_parsed_options<charT>
    basic_command_line_parser<charT>::run()
    {
        // save the canonical prefixes which were used by this cmdline parser
        //    eventually inside the parsed results
        //    This will be handy to format recognisable options
        //    for diagnostic messages if everything blows up much later on
        parsed_options result(m_desc, detail::cmdline::get_canonical_option_prefix());
        result.options = detail::cmdline::run();

        // Presense of parsed_options -> wparsed_options conversion
        // does the trick.
        return basic_parsed_options<charT>(result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %r15
movq %rsi, %rdi
callq 0xc4c8
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq %r15, -0x28(%rbp)
movl %eax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0xc4fe
leaq -0x60(%rbp), %r14
movq (%r14), %rax
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%r15)
leaq -0x80(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movaps %xmm0, (%r14)
movq %rax, 0x10(%r14)
callq 0xe860
movq %r14, %rdi
callq 0xe860
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a7d4
leaq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x20(%rbx)
movq (%rax), %rax
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0xe860
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e215
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xe860
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: 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>>>> boost::program_options::collect_unrecognized<char>(std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>> const&, boost::program_options::collect_unrecognized_mode)
std::vector< std::basic_string<charT> > 
    collect_unrecognized(const std::vector< basic_option<charT> >& options,
                         enum collect_unrecognized_mode mode)
    {
        std::vector< std::basic_string<charT> >  result;
        for(unsigned i = 0; i < options.size(); ++i)
        {
            if (options[i].unregistered ||
                (mode == include_positional && options[i].position_key != -1))
            {
                copy(options[i].original_tokens.begin(),
                     options[i].original_tokens.end(),
                     back_inserter(result));
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x2e36c
movq %rsi, %r15
xorl %r13d, %r13d
leaq (,%r13,2), %rsi
addq %r13, %rsi
shlq $0x5, %rsi
leaq (%rax,%rsi), %rdx
cmpb $0x0, 0x58(%rax,%rsi)
je 0x2e33c
movq 0x40(%rdx), %r12
movq 0x48(%rdx), %r14
subq %r12, %r14
sarq $0x5, %r14
testq %r14, %r14
jle 0x2e342
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe894
addq $0x20, %r12
decq %r14
cmpq $0x1, %r14
ja 0x2e31b
movq (%r15), %rax
movq 0x8(%r15), %rcx
jmp 0x2e342
cmpl $0x0, -0x2c(%rbp)
je 0x2e364
incl %r13d
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq %r13, %rdx
ja 0x2e2ea
jmp 0x2e36c
cmpl $-0x1, 0x20(%rdx)
jne 0x2e304
jmp 0x2e342
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xe470
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/any.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> boost::any_cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(boost::any&)
ValueType any_cast(any & operand)
    {
        typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;


        nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());

        // Attempt to avoid construction of a temporary object in cases when 
        // `ValueType` is not a reference. Example:
        // `static_cast<std::string>(*result);` 
        // which is equal to `std::string(*result);`
        typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
            boost::is_reference<ValueType>,
            ValueType,
            BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type
        >::type ref_type;

        return static_cast<ref_type>(*result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f2d8
testq %rax, %rax
je 0x2fed3
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf98c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bcde(%rip), %rax     # 0x4bbb8
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
callq 0x3008e
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
callq 0xb730
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/convert.hpp
// Function: 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>>>> boost::program_options::to_internal<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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>>>> const&)
std::vector<std::string> to_internal(const std::vector<T>& s)
        {
            std::vector<std::string> result;
            for (unsigned i = 0; i < s.size(); ++i)
                result.push_back(to_internal(s[i]));            
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x30b35
movq %rsi, %r14
movl $0x1, %r13d
leaq -0x38(%rbp), %r12
xorl %esi, %esi
leaq -0x48(%rbp), %r15
shlq $0x5, %rsi
addq %rax, %rsi
movq %r15, %rdi
callq 0x149a4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21f90
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x30b1c
callq 0xb430
movl %r13d, %esi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %r13d
cmpq %rsi, %rcx
ja 0x30af4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x30b5d
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x30b5d
callq 0xb430
movq %rbx, %rdi
callq 0xe470
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/demon386[P]git-store/./boost/program_options/detail/parsers.hpp
// Function: 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>>>> boost::program_options::detail::make_vector<char, char const* const*>(char const* const*, char const* const*)
std::vector<std::basic_string<charT> > 
        make_vector(Iterator i, Iterator e)
        {
            std::vector<std::basic_string<charT> > result;
            // Some compilers don't have templated constructor for 
            // vector, so we can't create vector from (argv+1, argv+argc) range
            for(; i != e; ++i)
                result.push_back(*i);
            return result;            
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
je 0x30bd6
movq %rdx, %r14
movq %rsi, %r15
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %r13
movq (%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xb1c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21f90
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x30bcd
callq 0xb430
addq $0x8, %r15
cmpq %r14, %r15
jne 0x30ba2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x30c02
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x30c02
callq 0xb430
movq %rbx, %rdi
callq 0xe470
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x5590
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5630
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x78a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7a14
jmp 0x7880
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x78be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5350
movq 0x416f3(%rip), %rsi     # 0x48fb8
leaq 0x20(%rsp), %rdi
callq 0x54c0
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7962
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7910
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5350
movq 0x416a1(%rip), %rsi     # 0x48fb8
leaq 0x20(%rsp), %rdi
callq 0x54c0
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
callq 0x86a0
movq %rbx, %rdi
callq 0x86a0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5540
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x8111
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x82f2
movq %rsp, %rdi
callq 0x50d0
movq %rsp, %rdi
callq 0x50f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq 0x40ed8(%rip), %rdi     # 0x48ff0
leaq 0x2f611(%rip), %rsi     # 0x37730
movl $0x10, %edx
callq 0x53b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x40eb9(%rip), %rdi     # 0x48ff0
callq 0x53b0
movq %rax, %rdi
callq 0x51a0
movl $0x1, %edi
callq 0x53e0
movq %rax, %r14
jmp 0x815e
movq %rax, %r14
movq %rsp, %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x845c
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
cmpq $0x2, %rcx
jb 0x12dfe
movsd (%rdx), %xmm0
movb $0x1, %al
ucomisd 0x8(%rdx), %xmm0
ja 0x12dfd
movl $0x2, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x12df7
movsd -0x8(%rdx,%rax,8), %xmm0
leaq 0x1(%rax), %rsi
ucomisd (%rdx,%rax,8), %xmm0
jbe 0x12dde
cmpq %rax, %rcx
seta %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x13ea0
leaq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x13ea0
movl 0x30(%r15), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r15), %rax
testq %rax, %rax
je 0x1335f
movq (%rax), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %r13
leaq 0x27393(%rip), %rax     # 0x3a658
cmpq %rax, %r13
je 0x13339
cmpb $0x2a, (%r13)
jne 0x132df
leaq 0x273a3(%rip), %rax     # 0x3a67b
cmpq %rax, %r13
jne 0x13355
jmp 0x13311
leaq 0x27372(%rip), %rsi     # 0x3a658
movq %r13, %rdi
callq 0x5490
testl %eax, %eax
je 0x13339
leaq 0x27382(%rip), %rax     # 0x3a67b
cmpq %rax, %r13
je 0x13311
leaq 0x27376(%rip), %rsi     # 0x3a67b
movq %r13, %rdi
callq 0x5490
testl %eax, %eax
jne 0x13355
movl $0x30, %edi
callq 0x5340
movq %rax, %r13
leaq 0x3558b(%rip), %rax     # 0x488b0
movq %rax, (%r13)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x137f6
jmp 0x13351
movl $0x8, %edi
callq 0x5340
movq %rax, %r13
leaq 0x3557b(%rip), %rax     # 0x488c8
movq %rax, (%r13)
movq %r13, 0x38(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5380
movq %rax, %r15
movl $0x30, %esi
movq %r13, %rdi
callq 0x5350
jmp 0x13379
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1338d
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x133a1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1348f
movq %rsi, %r14
movq %rbx, %rdi
callq 0x13ea0
leaq 0x18(%r14), %r15
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x13ea0
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1349e
movq (%rax), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %r12
leaq 0x27259(%rip), %rax     # 0x3a658
cmpq %rax, %r12
je 0x13473
cmpb $0x2a, (%r12)
jne 0x13419
leaq 0x27269(%rip), %rax     # 0x3a67b
cmpq %rax, %r12
jne 0x1348f
jmp 0x1344b
leaq 0x27238(%rip), %rsi     # 0x3a658
movq %r12, %rdi
callq 0x5490
testl %eax, %eax
je 0x13473
leaq 0x27248(%rip), %rax     # 0x3a67b
cmpq %rax, %r12
je 0x1344b
leaq 0x2723c(%rip), %rsi     # 0x3a67b
movq %r12, %rdi
callq 0x5490
testl %eax, %eax
jne 0x1348f
movl $0x30, %edi
callq 0x5340
movq %rax, %r12
leaq 0x35451(%rip), %rax     # 0x488b0
movq %rax, (%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x137f6
jmp 0x1348b
movl $0x8, %edi
callq 0x5340
movq %rax, %r12
leaq 0x35441(%rip), %rax     # 0x488c8
movq %rax, (%r12)
movq %r12, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5380
movq %rax, %rbx
movl $0x30, %esi
movq %r12, %rdi
callq 0x5350
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
cmpq %rsi, 0x8(%rdx)
je 0x13576
movq %rdx, %r14
leaq 0x18(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%r15), %r13
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x38(%r15), %rdi
addq %rbp, %rsi
movq (%rdi), %rax
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq %r13, %r8
callq *(%rax)
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1354f
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1355c
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x7cde
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %rbp
cmpq %r12, %rax
ja 0x1351a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1359f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x8(%rdx), %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
testq %rdx, %rdx
js 0x13659
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x1502a
cmpq $0x0, 0x8(%r14)
jle 0x13628
leaq 0x18(%r15), %rax
movq %rax, (%rsp)
leaq 0x30(%r15), %r13
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x38(%r15), %rdi
movq (%r14), %rsi
addq %rbp, %rsi
movq (%rdi), %rax
movq %r15, %rdx
movq (%rsp), %rcx
movq %r13, %r8
callq *(%rax)
cmpq %r12, 0x8(%rbx)
jle 0x1363a
movq (%rbx), %rax
movsd %xmm0, (%rax,%rbp)
incq %r12
addq $0x8, %rbp
cmpq %r12, 0x8(%r14)
jg 0x135f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26f4c(%rip), %rdi     # 0x3a58d
leaq 0x26f62(%rip), %rsi     # 0x3a5aa
leaq 0x26f82(%rip), %rcx     # 0x3a5d1
movl $0x198, %edx            # imm = 0x198
callq 0x5230
leaq 0x26cfa(%rip), %rdi     # 0x3a35a
leaq 0x26d7d(%rip), %rsi     # 0x3a3e4
leaq 0x26d9d(%rip), %rcx     # 0x3a40b
movl $0x138, %edx            # imm = 0x138
callq 0x5230
jmp 0x1367a
movq %rax, %r14
movq (%rbx), %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x34d9b(%rip), %rax     # 0x488b0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x13b26
callq 0x5410
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13b34
callq 0x5410
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x13b42
callq 0x5410
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x13b51
popq %rbx
jmp 0x5410
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::CubicSpline1D::CubicSpline1D(forrocket::interpolate::CubicSpline1D const&)
forrocket::interpolate::CubicSpline1D::CubicSpline1D(const CubicSpline1D& from) { 
    array_size = from.array_size;
    a_spline = new double[from.array_size];
    for (int i=0; i < from.array_size; ++i) {
        a_spline[i] = from.a_spline[i];
    }
    b_spline = new double[from.array_size];
    for (int i=0; i < from.array_size; ++i) {
        b_spline[i] = from.b_spline[i];
    }
    c_spline = new double[from.array_size];
    for (int i=0; i < from.array_size; ++i) {
        c_spline[i] = from.c_spline[i];
    }
    d_spline = new double[from.array_size];
    for (int i=0; i < from.array_size; ++i) {
        d_spline[i] = from.d_spline[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x34d47(%rip), %rax     # 0x488b0
movq %rax, (%rdi)
movslq 0x8(%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movl %r12d, 0x8(%rdi)
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
testq %r12, %r12
jle 0x13c34
movq 0x10(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13ba5
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
jle 0x13c40
movq 0x18(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13bce
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
testl %r12d, %r12d
jle 0x13c4c
movq 0x20(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13bf7
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
testl %r12d, %r12d
jle 0x13c58
movq 0x28(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13c20
jmp 0x13c58
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::CubicSpline1D::operator=(forrocket::interpolate::CubicSpline1D const&)
forrocket::interpolate::CubicSpline1D& forrocket::interpolate::CubicSpline1D::operator=(const CubicSpline1D& from) {
    if (this != &from) {
        array_size = from.array_size;
        a_spline = new double[from.array_size];
        for (int i=0; i < from.array_size; ++i) {
            a_spline[i] = from.a_spline[i];
        }
        b_spline = new double[from.array_size];
        for (int i=0; i < from.array_size; ++i) {
            b_spline[i] = from.b_spline[i];
        }
        c_spline = new double[from.array_size];
        for (int i=0; i < from.array_size; ++i) {
            c_spline[i] = from.c_spline[i];
        }
        d_spline = new double[from.array_size];
        for (int i=0; i < from.array_size; ++i) {
            d_spline[i] = from.d_spline[i];
        }
    }
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x13d67
movq %rsi, %r14
movslq 0x8(%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movl %r12d, 0x8(%rbx)
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
testq %r12, %r12
jle 0x13d43
movq 0x10(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13cb4
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
jle 0x13d4f
movq 0x18(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13cdd
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
testl %r12d, %r12d
jle 0x13d5b
movq 0x20(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13d06
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
testl %r12d, %r12d
jle 0x13d67
movq 0x28(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13d2f
jmp 0x13d67
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::CubicSpline1D::polate(double const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, int const&)
double forrocket::interpolate::CubicSpline1D::polate(const double& x, const std::vector<double>& x_src, const std::vector<double>& y_src, const int& fill_value) {
    int index_target;
    if (x < x_src[0]) {  // 左外挿
        switch (fill_value) {
        case 0:  // zero
            return 0;
            break;
        
        case 1:  // same
            return y_src[0];
            break;

        case 2:  // extrapolate
            index_target = 0;
            break;
        }
    }
    else if (x >= x_src[0] && x <= x_src[x_src.size()-1]) {  // 内挿
        for (int i=0; i < x_src.size(); ++i) {
            if (x <= x_src[i]) {
                index_target = i - 1;
                break;
            }
        }
    }
    else if (x > x_src[x_src.size()-1]) {  // 右外挿
        switch (fill_value) {
        case 0:  // zero
            return 0;
            break;
        
        case 1:  // same
            return y_src[y_src.size()-1];
            break;

        case 2:  // extrapolate
            index_target = x_src.size() - 1;
            break;
        }
    }

    double h = x - x_src[index_target];
    return a_spline[index_target] + b_spline[index_target] * h + c_spline[index_target] * std::pow(h, 2) + d_spline[index_target] * std::pow(h, 3);
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
callq 0x734c
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%r15), %xmm0
callq 0x734c
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x241f2(%rip), %xmm0    # 0x3a720
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16542
sqrtsd %xmm0, %xmm0
jmp 0x16547
callq 0x52b0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5640
movaps %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x5640
movaps %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x5640
movaps %xmm0, 0x40(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x50e0
movaps %xmm0, 0x20(%rsp)
movsd 0x24171(%rip), %xmm0    # 0x3a720
subsd 0x30(%r14), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
mulsd 0x8(%rsp), %xmm0
movapd 0x50(%rsp), %xmm2
unpcklpd 0x40(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
movapd 0x60(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sus304[P]ForRocket/src/environment/coordinate.cpp
// Function: forrocket::Coordinate::EulerAngle()
Eigen::Vector3d forrocket::Coordinate::EulerAngle() {
    // return: radian
    double azimuth = std::atan2(dcm.NED2body(0, 1), dcm.NED2body(0, 0));
    double elevation = -std::asin(dcm.NED2body(0, 2));
    double roll = std::atan2(dcm.NED2body(1, 2), dcm.NED2body(2, 2));
    Eigen::Vector3d euler;
    euler << azimuth, elevation, roll;
    return euler;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xd0(%rsi), %xmm1
movsd 0xe8(%rsi), %xmm0
callq 0x5080
movsd %xmm0, 0x8(%rsp)
movsd 0x100(%r14), %xmm0
callq 0x5580
xorps 0x23c71(%rip), %xmm0    # 0x3a710
leaq 0x38(%rsp), %r15
movlps %xmm0, (%r15)
movsd 0x108(%r14), %xmm0
movsd 0x110(%r14), %xmm1
callq 0x5080
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movq %rbx, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movq %r15, %rsi
callq 0x16d64
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x16d64
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
cmpq $0x3, %rax
jne 0x16b26
cmpq $0x1, 0x28(%rsp)
jne 0x16b26
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23c1b(%rip), %rdi     # 0x3a748
leaq 0x23cb2(%rip), %rsi     # 0x3a7e6
leaq 0x23e9d(%rip), %rcx     # 0x3a9d8
movl $0x78, %edx
callq 0x5230
movq 0x30(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x16b65
cmpq $0x1, 0x28(%rsp)
jne 0x16b65
movq %rax, %rdi
callq 0x55e0
callq 0x599c