LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: (anonymous namespace)::convert_aux(wchar_t const*, wchar_t const*, char*, char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
void convert_aux(
                   const wchar_t* from,
                   const wchar_t* from_end,
                   char* to, char* to_end,
                   std::string & target,
                   const pt::codecvt_type & cvt)
  {
    //std::cout << std::hex
    //          << " from=" << std::size_t(from)
    //          << " from_end=" << std::size_t(from_end)
    //          << " to=" << std::size_t(to)
    //          << " to_end=" << std::size_t(to_end)
    //          << std::endl;

    std::mbstate_t state  = std::mbstate_t();  // perhaps unneeded, but cuts bug reports
    const wchar_t* from_next;
    char* to_next;

    std::codecvt_base::result res;

    if ((res=cvt.out(state, from, from_end, from_next,
           to, to_end, to_next)) != std::codecvt_base::ok)
    {
      //std::cout << " result is " << static_cast<int>(res) << std::endl;
      BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(),
        "boost::filesystem::path codecvt to string"));
    }
    target.append(to, to_next); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %rax
movq %rdx, %r14
movq %rsi, %rcx
movq %rdi, %rdx
leaq -0x30(%rbp), %rsi
andq $0x0, (%rsi)
movq (%r9), %r10
leaq -0x20(%rbp), %r11
leaq -0x28(%rbp), %r8
movq %r9, %rdi
movq %r14, %r9
pushq %r11
pushq %rax
callq *0x10(%r10)
addq $0x10, %rsp
testl %eax, %eax
jne 0x26d1a
movq -0x20(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144e8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
pushq $0x40
popq %rdi
callq 0xc250
movq %rax, %rbx
callq 0x21bd8
leaq 0x9d9a(%rip), %rcx      # 0x30ace
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x26d6c
leaq 0x21827(%rip), %rsi     # 0x48570
leaq -0x2010(%rip), %rdx     # 0x24d40
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26e2f
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x20, (%rax)
jne 0x26e34
xorl %r14d, %r14d
jmp 0x26e4e
leaq 0x2285d(%rip), %rsi     # 0x49698
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc470
cmpq $-0x1, %rax
je 0x26e56
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 0x26e2f
movb $0x1, %r14b
cmpl $0x2e, %ecx
jne 0x26e4e
cmpq $0x1, %rax
je 0x26e4e
leaq 0x9953(%rip), %rsi      # 0x307cf
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xef68
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26ee6
movq %rdi, %rbx
leaq 0x9930(%rip), %rsi      # 0x307d0
callq 0xef68
movb $0x1, %r14b
testb %al, %al
jne 0x26ee9
leaq 0x991c(%rip), %rsi      # 0x307cf
movq %rbx, %rdi
callq 0xef68
testb %al, %al
jne 0x26ee9
movq %rbx, %rdi
callq 0x26e16
testb %al, %al
je 0x26ee6
movq %rbx, %rdi
callq 0x26df1
testb %al, %al
je 0x26ee6
movq (%rbx), %rax
movb (%rax), %al
addb $-0x2f, %al
cmpb $-0x2, %al
setb %r14b
jmp 0x26ee9
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x98ce(%rip), %rsi      # 0x307d0
callq 0xef68
movb $0x1, %r14b
testb %al, %al
jne 0x26f47
leaq 0x98ba(%rip), %rsi      # 0x307cf
movq %rbx, %rdi
callq 0xef68
testb %al, %al
jne 0x26f47
movq %rbx, %rdi
callq 0x26e88
testb %al, %al
je 0x26f44
pushq $0x2e
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
sete %r14b
jmp 0x26f47
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26e88
testb %al, %al
je 0x26fb3
leaq 0x9867(%rip), %rsi      # 0x307d0
movq %rbx, %rdi
callq 0x26fcb
testb %al, %al
je 0x26fb3
leaq 0x9853(%rip), %rsi      # 0x307cf
movq %rbx, %rdi
callq 0x26fcb
testb %al, %al
je 0x26fb3
pushq $0x2e
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc610
cmpq $-0x1, %rax
je 0x26fba
movq %rax, %r14
leaq 0x1(%rax), %rdx
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xc610
cmpq $-0x1, %rax
je 0x26fbe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x26fb5
addq $0x5, %r14
cmpq 0x8(%rbx), %r14
seta %al
jmp 0x26fb5
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2718b
movq %rsi, %rbx
callq 0x2761f
movl %r14d, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0xc250
movq %rax, %rbx
callq 0x2761f
leaq 0x99e0(%rip), %rcx      # 0x30b82
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x26d6c
leaq 0x213b9(%rip), %rsi     # 0x48570
leaq -0x247e(%rip), %rdx     # 0x24d40
movq %rbx, %rdi
callq 0xc810
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
movq %rsi, %rax
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x2720e
movq (%rax), %rdi
addq %rdi, %rsi
movq %rbx, %rdx
callq 0x27267
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc990
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x28951
movq %rax, %r12
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29002
movq %r12, %rdi
movq %r15, %rsi
callq 0x289cc
leaq -0x60(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28a36
movq %rbx, %rdi
callq 0x28a56
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x28a56
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9084(%rip), %rsi      # 0x30feb
callq 0xc150
testq %rax, %rax
je 0x27fc4
movq %rax, %r14
leaq -0xa0(%rbp), %r15
xorb $0x1, %bl
leaq 0x9012(%rip), %r12      # 0x30f97
movq %r14, %rdi
callq 0xc760
testl %eax, %eax
jne 0x27fba
movq %r15, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0xc780
testq %rax, %rax
sete %al
orb %bl, %al
jne 0x27f85
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xc070
jmp 0x27f85
movq %r14, %rdi
callq 0xc6a0
jmp 0x27fc7
pushq $-0x1
popq %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/main.cpp
// Function: process_read_cmd(boost::program_options::variables_map const&)
void process_read_cmd(const po::variables_map& options) {
    if (!options.count("subargs")) {
        return;
    }
    auto subargs = options["subargs"].as<std::vector<std::string>>();
    if (subargs.size() != 1) {
        std::cout << "should given exactly one SHA-1" << std::endl;
    }
    subprocess::run_cmd("git reset --mixed");
    int ret = subprocess::run_cmd("git read-tree " + subargs.at(0));
    if (ret == 0) {
        subprocess::run_cmd("git checkout-index -a");
        subprocess::run_cmd("git reset --mixed");
    } else {
        std::cerr << "Trying to find blob object with this SHA-1" << std::endl;
        subprocess::run_cmd("git show " + subargs.at(0));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8b85(%rip), %rsi      # 0x30f2b
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xc1b0
leaq 0x10(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2101c
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xc9a0
testq %r14, %r14
je 0x28531
leaq 0x8b4f(%rip), %rsi      # 0x30f2b
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x20cf2
movq %rax, %rdi
callq 0x2ad4b
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x10d3a
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
cmpq $0x20, %rax
je 0x2843b
movq 0x20b91(%rip), %rdi     # 0x48fb8
leaq 0x8c5f(%rip), %rsi      # 0x3108d
callq 0xc4c0
movq %rax, %rdi
callq 0xc230
leaq 0x8c2a(%rip), %rsi      # 0x3106c
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
leaq -0x38(%rbp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x27f49
movq %rbx, %rdi
callq 0xc9a0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x28e52
leaq 0x8c34(%rip), %rsi      # 0x310ac
leaq -0x38(%rbp), %rdi
movq %rax, %rdx
callq 0x15d84
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x27f49
movl %eax, %r14d
movq %rbx, %rdi
callq 0xc9a0
testl %r14d, %r14d
je 0x284da
movq 0x20b4a(%rip), %rdi     # 0x48ff0
leaq 0x8c24(%rip), %rsi      # 0x310d1
callq 0xc4c0
movq %rax, %rdi
callq 0xc230
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x28e52
leaq 0x8c30(%rip), %rsi      # 0x310fc
leaq -0x38(%rbp), %rdi
movq %rax, %rdx
callq 0x15d84
jmp 0x28515
leaq 0x8bda(%rip), %rsi      # 0x310bb
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x27f49
movq %rbx, %rdi
callq 0xc9a0
leaq 0x8b64(%rip), %rsi      # 0x3106c
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc1b0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x27f49
movq %rbx, %rdi
callq 0xc9a0
leaq -0x50(%rbp), %rdi
callq 0xe840
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2854f
jmp 0x2854f
jmp 0x2854f
jmp 0x2854f
jmp 0x2854a
jmp 0x2854f
jmp 0x2854f
jmp 0x2855d
movq %rax, %rbx
jmp 0x28569
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xe840
jmp 0x28569
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %r15
movq %rsi, %rdi
callq 0xcf48
andq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %r15, -0x28(%rbp)
movl %eax, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0xcf82
leaq -0x40(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x12292
movq %r15, %rdi
callq 0xeac8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x184ac
leaq -0x40(%rbp), %rdi
callq 0xeac8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28bd3
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xeac8
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
pushq $0x60
popq %r13
movl %r12d, %r12d
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x28d0f
imulq $0x60, %r12, %rdx
leaq (%rcx,%rdx), %rax
cmpb $0x0, 0x58(%rcx,%rdx)
je 0x28cfd
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
movq %rbx, %rdx
callq 0x2ad0a
jmp 0x28d02
testl %r14d, %r14d
je 0x28d07
incl %r12d
jmp 0x28cc5
cmpl $-0x1, 0x20(%rax)
jne 0x28ceb
jmp 0x28d02
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 0xe840
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./boost/algorithm/string/join.hpp
// Function: boost::range_value<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>>>>>::type boost::algorithm::join<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>>>>, char [2]>(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&, char const (&) [2])
inline typename range_value<SequenceSequenceT>::type 
        join(
            const SequenceSequenceT& Input,
            const Range1T& Separator)
        {
            // Define working types
            typedef typename range_value<SequenceSequenceT>::type ResultT;
            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;

            // Parse input
            InputIteratorT itBegin=::boost::begin(Input);
            InputIteratorT itEnd=::boost::end(Input);

            // Construct container to hold the result
            ResultT Result;
            
            // Append first element
            if(itBegin!=itEnd)
            {
                detail::insert(Result, ::boost::end(Result), *itBegin);
                ++itBegin;
            }

            for(;itBegin!=itEnd; ++itBegin)
            {
                // Add separator
                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
                // Add element
                detail::insert(Result, ::boost::end(Result), *itBegin);
            }

            return Result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
leaq 0x10(%rdi), %rsi
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
cmpq %r12, %r14
je 0x28de7
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2addd
jmp 0x28de3
jmp 0x28e3e
addq $0x20, %r14
cmpq %r12, %r14
je 0x28e2a
movq (%rbx), %r13
movq 0x8(%rbx), %r15
movq -0x30(%rbp), %rdi
callq 0x2ae08
addq %r15, %r13
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x40(%rbp), %rdx
callq 0x2adf4
movq (%rbx), %rsi
addq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2addd
jmp 0x28de3
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28e3e
movq %rax, %r14
movq %rbx, %rdi
callq 0xc9a0
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29a55
testq %rax, %rax
je 0x2a29e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc660
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1e91b(%rip), %rax     # 0x48bc0
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2a3e2
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
callq 0xc790
movq %rbx, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x2ab31
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x13d50
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e7fc
movq %r15, %rdi
callq 0xc9a0
incl %r12d
jmp 0x2aaf1
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0xc9a0
jmp 0x2ab52
movq %rax, %r14
movq %rbx, %rdi
callq 0xe840
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %r13
cmpq %r14, %r15
je 0x2abbb
movq (%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xc1b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e7fc
movq %r12, %rdi
callq 0xc9a0
addq $0x8, %r15
jmp 0x2ab8f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2abde
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xe840
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_11.cc
// Function: main
int main(int argc, char const *argv[])
{
	shared_ptr<int> p(new int(42));

	cout << p.use_count() << endl;
	process(shared_ptr<int>(p.get()));
	cout << p.use_count() << endl;


	// cout << *p << endl; //undefined,  the memory to which p points was freed

	// why execute p.reset() won't corrupt.
	// p.reset(); // double freed or corruption was generated.

	// delete p.get(); // double freed or corruption was generated.

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
pushq $0x4
popq %rdi
callq 0x1090
movl $0x2a, (%rax)
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13dc
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x12aa
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x12ac
xorl %esi, %esi
leaq -0x28(%rbp), %rbx
movq 0x2d21(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
callq 0x1050
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x13dc
leaq -0x20(%rbp), %rdi
callq 0x122c
leaq -0x18(%rbp), %rdi
callq 0x133e
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x12f4
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x12f6
xorl %esi, %esi
movq 0x2cdb(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x133e
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x18(%rbp), %rdi
callq 0x133e
jmp 0x132e
movq %rax, %r14
movq %rbx, %rdi
callq 0x133e
movq %r14, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/commandline_option.cpp
// Function: forrocket::DisplayHelp()
void forrocket::DisplayHelp() {
    std::cout << "Usage: ForRocket [option] config.json" << std::endl;
    std::cout << "Option:" << std::endl;
    std::cout << "  -m                 Decrease column of trajectory log" << std::endl;
    std::cout << "  -q or --quite      Disable announce message." << std::endl;
    std::cout << "  -h or --help       Display this information and exit." << std::endl;
    std::cout << "  -v or --version    Display solver version and exit." << std::endl;
}

// Assembly:
pushq %rbx
movq 0x43528(%rip), %rbx     # 0x48fc0
leaq 0x28579(%rip), %rsi     # 0x2e018
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
callq 0x51a0
leaq 0x28588(%rip), %rsi     # 0x2e03e
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
callq 0x51a0
leaq 0x28579(%rip), %rsi     # 0x2e046
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
callq 0x51a0
leaq 0x28599(%rip), %rsi     # 0x2e07d
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
callq 0x51a0
leaq 0x285b1(%rip), %rsi     # 0x2e0ac
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
callq 0x51a0
leaq 0x285d2(%rip), %rsi     # 0x2e0e4
movq %rbx, %rdi
callq 0x5320
movq %rax, %rdi
popq %rbx
jmp 0x51a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x5560
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5d81
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e58
jmp 0x5d59
leaq 0x8(%rsp), %rdi
callq 0x5688
leaq 0x28(%rsp), %rdi
callq 0x5190
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e14
leaq 0x8(%rsp), %rdi
callq 0x5688
leaq 0x28(%rsp), %rdi
callq 0x5190
movq %r14, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %esi, %esi
callq 0x67b2
movq %rsp, %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x5510
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x6666
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x67ce
movq %rsp, %rdi
callq 0x50d0
movq %rsp, %rdi
callq 0x5100
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq 0x42983(%rip), %rdi     # 0x48ff0
leaq 0x2808c(%rip), %rsi     # 0x2e700
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
movq %rax, %rdi
callq 0x51a0
pushq $0x1
popq %rdi
callq 0x53b0
movq %rax, %r14
jmp 0x66a4
movq %rax, %r14
movq %rsp, %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x68a0
movq %r14, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
sarq $0x3, %rax
pushq $0x1
popq %rsi
movq %rsi, %rdx
cmpq %rsi, %rax
jbe 0xefe6
movsd -0x8(%rcx,%rdx,8), %xmm0
leaq 0x1(%rdx), %rsi
ucomisd (%rcx,%rdx,8), %xmm0
jbe 0xefcd
cmpq %rdx, %rax
seta %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/src/interpolate.cpp
// Function: forrocket::interpolate::Interp1d::ascending_order_sort(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void forrocket::interpolate::Interp1d::ascending_order_sort(std::vector<double>& x, std::vector<double>& y) {
    std::vector<std::pair<double, double> > v1;
    for (int i=0; i < x.size(); ++i) {
        v1.push_back(std::make_pair(x[i], y[i]));
    }
    // stable_sort(v1.begin(), v1.end(), less);
    stable_sort(v1.begin(), v1.end());
    for (int i=0; i < v1.size(); ++i) {
        x[i] = v1[i].first;
        y[i] = v1[i].second;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsp, %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0xf056
movq (%rbx), %rcx
movsd (%rax,%r13,8), %xmm0
movsd (%rcx,%r13,8), %xmm1
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xff1a
incq %r13
jmp 0xf018
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10099
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
addq $0x8, %rax
xorl %edi, %edi
cmpq %rdi, %rcx
je 0xf0a1
movsd -0x8(%rax), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
movsd (%rax), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
addq $0x10, %rax
jmp 0xf080
movq %rsp, %rdi
callq 0xfee6
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xf0b9
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfee6
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xfd6a
leaq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xfd6a
movl 0x30(%r15), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r15), %rax
testq %rax, %rax
je 0xf3a7
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x39569(%rip), %rsi     # 0x488a8
callq 0x7e60
testb %al, %al
je 0xf360
pushq $0x8
popq %rdi
callq 0x5330
movq %rax, %r13
leaq 0x39546(%rip), %rax     # 0x488a0
movq %rax, (%r13)
jmp 0xf399
movq 0x38(%r15), %rax
testq %rax, %rax
je 0xf3a7
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x39549(%rip), %rsi     # 0x488c0
callq 0x7e60
testb %al, %al
je 0xf39d
pushq $0x30
popq %rdi
callq 0x5330
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf764
movq %r13, 0x38(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5370
movq %rax, %r15
pushq $0x30
popq %rsi
movq %r13, %rdi
callq 0x5340
jmp 0xf3bf
movq %rax, %r15
movq %r14, %rdi
callq 0x6002
movq %rbx, %rdi
callq 0x6002
movq %r15, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf483
movq %rsi, %r14
movq %rbx, %rdi
callq 0xfd6a
leaq 0x18(%r14), %r15
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xfd6a
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xf492
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x39483(%rip), %rsi     # 0x488a8
callq 0x7e60
testb %al, %al
je 0xf446
pushq $0x8
popq %rdi
callq 0x5330
movq %rax, %r12
leaq 0x39460(%rip), %rax     # 0x488a0
movq %rax, (%r12)
jmp 0xf47f
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xf492
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x39463(%rip), %rsi     # 0x488c0
callq 0x7e60
testb %al, %al
je 0xf483
pushq $0x30
popq %rdi
callq 0x5330
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf764
movq %r12, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5370
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x5340
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rsi), %r12
leaq 0x30(%rsi), %r13
xorl %ebp, %ebp
xorl %ebx, %ebx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rbx, %rax
jbe 0xf542
movq 0x38(%r15), %rdi
addq %rbp, %rsi
movq (%rdi), %rax
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq *(%rax)
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x62f0
incq %rbx
addq $0x8, %rbp
jmp 0xf4fc
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x6002
movq %r14, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rdx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdi, (%rsp)
callq 0xfe42
leaq 0x18(%r15), %r12
leaq 0x30(%r15), %r13
xorl %ebp, %ebp
cmpq %rbp, 0x8(%r14)
jle 0xf5ea
movq 0x38(%r15), %rbx
movq %r14, %rdi
movq %rbp, %rsi
callq 0xfe72
movq (%rbx), %r9
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq *(%r9)
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0xfea8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %rbp
jmp 0xf59f
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfede
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38e3b(%rip), %rax     # 0x48888
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xfa5e
callq 0x53e0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xfa6c
callq 0x53e0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xfa7a
callq 0x53e0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xfa89
popq %rbx
jmp 0x53e0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38de6(%rip), %rax     # 0x48888
movq %rax, (%rdi)
movslq 0x8(%rsi), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movl %r13d, 0x8(%rdi)
pushq $-0x1
popq %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rcx
xorl %edx, %edx
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
cmpq %rdx, %r12
je 0xfaf3
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfadf
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%r14)
movq 0x18(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfb19
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfb05
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfb3f
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfb2b
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%r14)
movq 0x28(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfb65
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfb51
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xfc48
movq %rsi, %r14
movslq 0x8(%rsi), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movl %r13d, 0x8(%rbx)
pushq $-0x1
popq %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rcx
xorl %edx, %edx
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
cmpq %rdx, %r12
je 0xfbd6
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfbc2
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfbfc
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfbe8
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfc22
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfc0e
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
movq 0x28(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0xfc48
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xfc34
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xfc83
movl (%r8), %edx
testl %edx, %edx
je 0xfcc7
cmpl $0x1, %edx
jne 0xfcf5
movq (%rcx), %rax
movsd (%rax), %xmm0
jmp 0xfd58
movq 0x8(%rdx), %rdx
subq %rax, %rdx
ucomisd %xmm1, %xmm0
jb 0xfc9c
movsd -0x8(%rax,%rdx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xfcd0
ucomisd -0x8(%rax,%rdx), %xmm0
jbe 0xfcf5
movl (%r8), %esi
testl %esi, %esi
je 0xfcc7
cmpl $0x2, %esi
je 0xfd5d
cmpl $0x1, %esi
jne 0xfcf5
movq 0x8(%rcx), %rax
movsd -0x8(%rax), %xmm0
jmp 0xfd58
xorpd %xmm0, %xmm0
jmp 0xfd58
sarq $0x3, %rdx
negq %rdx
pushq $-0x1
popq %rcx
leaq (%rdx,%rcx), %rsi
cmpq $-0x1, %rsi
je 0xfcf5
movsd 0x8(%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0xfcf7
incq %rcx
jmp 0xfcda
xorl %ecx, %ecx
movslq %ecx, %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 0x216f1(%rip), %xmm1    # 0x31438
callq 0x55a0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
shrq $0x3, %rdx
decq %rdx
movq %rdx, %rcx
jmp 0xfcf7
nop
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/Eigen/src/Core/DenseCoeffsBase.h
// Function: Eigen::DenseCoeffsBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>::operator[](long) const
CoeffReturnType
    operator[](Index index) const
    {
      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
      eigen_assert(index >= 0 && index < size());
      return coeff(index);
    }

// Assembly:
testq %rsi, %rsi
js 0xfe88
cmpq %rsi, 0x8(%rdi)
jle 0xfe88
shlq $0x3, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x2188d(%rip), %rdi     # 0x3171d
leaq 0x218a3(%rip), %rsi     # 0x3173a
leaq 0x2194a(%rip), %rcx     # 0x317e8
movl $0xa2, %edx
callq 0x5240
// File: /workspace/github_cpp_makefile_star2_O2/sus304[P]ForRocket/./lib/Eigen/src/Core/DenseCoeffsBase.h
// Function: Eigen::DenseCoeffsBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1>::operator[](long)
Scalar&
    operator[](Index index)
    {
      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
      eigen_assert(index >= 0 && index < size());
      return coeffRef(index);
    }

// Assembly:
testq %rsi, %rsi
js 0xfebe
cmpq %rsi, 0x8(%rdi)
jle 0xfebe
shlq $0x3, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x21857(%rip), %rdi     # 0x3171d
leaq 0x2186d(%rip), %rsi     # 0x3173a
leaq 0x2188d(%rip), %rcx     # 0x31761
movl $0x198, %edx            # imm = 0x198
callq 0x5240