LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: (anonymous namespace)::convert_aux(char const*, char const*, wchar_t*, wchar_t*, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
void convert_aux(
                   const char* from,
                   const char* from_end,
                   wchar_t* to, wchar_t* to_end,
                   std::wstring & 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 char* from_next;
    wchar_t* to_next;

    std::codecvt_base::result res;

    if ((res=cvt.in(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 wstring"));
    }
    target.append(to, to_next); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rax
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rdx
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
movq (%r9), %r10
leaq -0x20(%rbp), %r11
leaq -0x28(%rbp), %r8
movq %r9, %rdi
movq %rbx, %r9
pushq %r11
pushq %rax
callq *0x20(%r10)
addq $0x10, %rsp
testl %eax, %eax
jne 0x2bc26
movq -0x20(%rbp), %r8
movq 0x8(%r14), %rsi
subq %rbx, %r8
sarq $0x2, %r8
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb130
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movl $0x40, %edi
callq 0xb250
movq %rax, %rbx
callq 0x25ee0
leaq 0xadc9(%rip), %rcx      # 0x36a0b
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2be24
leaq 0x1f8f9(%rip), %rsi     # 0x4b550
leaq -0x2228(%rip), %rdx     # 0x29a36
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/demon386[P]git-store/./libs/filesystem/src/path_traits.cpp
// Function: boost::filesystem::path_traits::convert(wchar_t const*, wchar_t const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::codecvt<wchar_t, char, __mbstate_t> const&)
BOOST_FILESYSTEM_DECL
  void convert(const wchar_t* from,
                const wchar_t* from_end,  // 0 for null terminated MBCS
                std::string & to,
                const codecvt_type & cvt)
  {
    BOOST_ASSERT(from);

    if (!from_end)  // null terminated
    {
      from_end = from + std::wcslen(from);
    }

    if (from == from_end) return;

    //  The codecvt length functions may not be implemented, and I don't really
    //  understand them either. Thus this code is just a guess; if it turns
    //  out the buffer is too small then an error will be reported and the code
    //  will have to be fixed.
    std::size_t buf_size = (from_end - from) * 4;  // perhaps too large, but that's OK
    buf_size += 4;  // encodings like shift-JIS need some prefix space

    //  dynamically allocate a buffer only if source is unusually large
    if (buf_size > default_codecvt_buf_size)
    {
      boost::scoped_array< char > buf(new char [buf_size]);
      convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt);
    }
    else
    {
      char buf[default_codecvt_buf_size];
      convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testq %rdi, %rdi
je 0x2bd34
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rsi, %rsi
jne 0x2bcb3
movq %r15, %rdi
callq 0xb3e0
leaq (%r15,%rax,4), %r12
movq %r12, %r13
subq %r15, %r13
je 0x2bd22
addq $0x4, %r13
cmpq $0x101, %r13            # imm = 0x101
jb 0x2bd06
movq %r13, %rdi
callq 0xb030
movq %rbx, %r9
movq %rax, %rbx
addq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x2bd66
movq %rbx, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb5a0
leaq -0x30(%rbp), %rcx
leaq -0x130(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %rbx, %r9
callq 0x2bd66
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa7a7(%rip), %rdi      # 0x364e2
leaq 0xabc0(%rip), %rsi      # 0x36902
leaq 0xac4e(%rip), %rcx      # 0x36997
movl $0xac, %edx
callq 0xb310
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5a0
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rcx, %rax
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rdx
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
movq (%r9), %r10
leaq -0x20(%rbp), %r11
leaq -0x28(%rbp), %r8
movq %r9, %rdi
movq %rbx, %r9
pushq %r11
pushq %rax
callq *0x10(%r10)
addq $0x10, %rsp
testl %eax, %eax
jne 0x2bdd0
movq -0x20(%rbp), %r8
movq 0x8(%r14), %rsi
subq %rbx, %r8
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb4f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movl $0x40, %edi
callq 0xb250
movq %rax, %rbx
callq 0x25ee0
leaq 0xac4a(%rip), %rcx      # 0x36a36
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2be24
leaq 0x1f74f(%rip), %rsi     # 0x4b550
leaq -0x23d2(%rip), %rdx     # 0x29a36
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_O1/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 0x2bee4
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x20, (%rax)
jne 0x2bee9
xorl %r14d, %r14d
jmp 0x2bf0a
movq 0x20770(%rip), %rsi     # 0x4c660
movq 0x20771(%rip), %rcx     # 0x4c668
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb6c0
cmpq $-0x1, %rax
je 0x2bf12
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 0x2bee4
movb $0x1, %r14b
cmpl $0x2e, %ecx
jne 0x2bf0a
cmpq $0x1, %rax
je 0x2bf0a
leaq 0xa7b4(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
sete %r14b
jmp 0x2bf0a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bfc5
movq %rdi, %rbx
leaq 0xa78d(%rip), %rsi      # 0x366ed
callq 0xb110
movb $0x1, %r14b
testl %eax, %eax
je 0x2bfc8
leaq 0xa779(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2bfc8
movq %rbx, %rdi
callq 0x2becb
xorl %r14d, %r14d
testb %al, %al
je 0x2bfc8
cmpq $0x0, 0x8(%rbx)
je 0x2bfc8
movq 0x206e4(%rip), %rsi     # 0x4c680
movq 0x206e5(%rip), %rcx     # 0x4c688
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb7a0
cmpq $-0x1, %rax
jne 0x2bfc8
movq (%rbx), %rax
movb (%rax), %al
addb $-0x2f, %al
cmpb $-0x2, %al
setb %r14b
jmp 0x2bfc8
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa70c(%rip), %rsi      # 0x366ed
callq 0xb110
movb $0x1, %r14b
testl %eax, %eax
je 0x2c028
leaq 0xa6f8(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2c028
movq %rbx, %rdi
callq 0x2bf48
testb %al, %al
je 0x2c025
movq %rbx, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
sete %r14b
jmp 0x2c028
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bf48
testb %al, %al
je 0x2c098
leaq 0xa6a3(%rip), %rsi      # 0x366ed
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2c098
leaq 0xa68f(%rip), %rsi      # 0x366ec
movq %rbx, %rdi
callq 0xb110
testl %eax, %eax
je 0x2c098
movq %rbx, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0xb5c0
cmpq $-0x1, %rax
je 0x2c09f
movq %rax, %r14
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0xb5c0
cmpq $-0x1, %rax
je 0x2c0a3
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x2c09a
addq $0x5, %r14
cmpq 0x8(%rbx), %r14
seta %al
jmp 0x2c09a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c2b0
movq %rsi, %rbx
callq 0x2c80a
movl %r14d, (%rbx)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x40, %edi
callq 0xb250
movq %rax, %rbx
callq 0x2c80a
leaq 0xa819(%rip), %rcx      # 0x36ae2
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x2be24
leaq 0x1f272(%rip), %rsi     # 0x4b550
leaq -0x28af(%rip), %rdx     # 0x29a36
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c349
movq (%rsi), %r15
callq 0x2b7ac
addq %r15, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2bab4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2c365
callq 0xb430
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f906(%rip), %al      # 0x4c748
testb %al, %al
je 0x2cf1f
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 0x2ce7e
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 0x2ce9f
movq %rcx, -0x40(%rbp)
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
jmp 0x2cea6
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 0x1f853(%rip), %rdi     # 0x4c718
movq %rbx, %rsi
callq 0x2e7d0
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 0x2f198
movq 0x20(%r14), %rdi
cmpq %r15, %rdi
je 0x2cefd
callq 0xb430
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x2cf14
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 0xbccb
jmp 0x2ce4a
movq %rax, %rdi
callq 0xe997
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2e850
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x95b2(%rip), %rsi      # 0x36f4b
callq 0xb150
testq %rax, %rax
je 0x2da00
movq %rax, %r14
movq %rax, %rdi
callq 0xb700
testl %eax, %eax
jne 0x2d9f6
leaq -0xa0(%rbp), %r15
xorb $0x1, %bl
leaq 0x9534(%rip), %r12      # 0x36ef7
movq %r15, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0xb720
testq %rax, %rax
sete %al
orb %bl, %al
jne 0x2d9ea
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r14, %rdi
callq 0xb700
testl %eax, %eax
je 0x2d9c3
movq %r14, %rdi
callq 0xb620
jmp 0x2da05
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_O1/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %r15
movq %rsi, %rdi
callq 0xc4e4
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq %r15, -0x28(%rbp)
movl %eax, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0xc51a
leaq -0x70(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq -0x40(%rbp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rax
leaq -0x58(%rbp), %r15
movups (%r15), %xmm1
movaps %xmm1, (%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%r14)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movups %xmm1, (%r15)
movq $0x0, 0x10(%r15)
callq 0xe8e2
movq %r15, %rdi
callq 0xe8e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a93c
leaq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x20(%rbx)
movq (%rax), %rax
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0xe8e2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e9e1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xe8e2
movq %rbx, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rax, 0x8(%rsi)
je 0x2eb32
movq %rsi, %r15
xorl %r13d, %r13d
leaq (,%r13,2), %rdx
addq %r13, %rdx
shlq $0x5, %rdx
leaq (%rax,%rdx), %rcx
cmpb $0x0, 0x58(%rax,%rdx)
je 0x2eafe
movq 0x40(%rcx), %r12
movq 0x48(%rcx), %r14
subq %r12, %r14
sarq $0x5, %r14
testq %r14, %r14
jle 0x2eb04
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe916
addq $0x20, %r12
decq %r14
cmpq $0x1, %r14
jg 0x2eae4
jmp 0x2eb04
cmpl $0x0, -0x2c(%rbp)
je 0x2eb2a
incl %r13d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r13, %rcx
ja 0x2eab3
jmp 0x2eb32
cmpl $-0x1, 0x20(%rcx)
jne 0x2eacd
jmp 0x2eb04
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 0xe51e
movq %r14, %rdi
callq 0xb7f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2faba
testq %rax, %rax
je 0x306cc
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xfa18
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1b4e5(%rip), %rax     # 0x4bbb8
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
callq 0x30894
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
callq 0xb730
movq %rbx, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31359
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 0x14b1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2214a
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x31340
callq 0xb430
movl %r13d, %esi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %r13d
cmpq %rsi, %rcx
ja 0x31318
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x31381
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x31381
callq 0xb430
movq %rbx, %rdi
callq 0xe51e
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x313fa
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 0x2214a
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x313f1
callq 0xb430
addq $0x8, %r15
cmpq %r14, %r15
jne 0x313c6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x31426
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x31426
callq 0xb430
movq %rbx, %rdi
callq 0xe51e
movq %r14, %rdi
callq 0xb7f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movl $0x4, %edi
callq 0x10a0
movl $0x2a, (%rax)
leaq -0x10(%rbp), %rbx
movq %rax, -0x8(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x145e
movq (%rbx), %rax
testq %rax, %rax
je 0x12f8
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x12fa
xorl %esi, %esi
movq 0x2cd7(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rsi, -0x8(%rdi)
callq 0x145e
leaq -0x28(%rbp), %rdi
callq 0x124c
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1358
callq 0x13e4
movq -0x10(%rbp), %rax
testq %rax, %rax
je 0x1369
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x136b
xorl %esi, %esi
movq 0x2c66(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x13af
callq 0x13e4
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x13ce
callq 0x13e4
jmp 0x13ce
movq %rax, %rbx
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x13dc
callq 0x13e4
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x792c
jmp 0x77a0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x77de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5350
movq 0x417d3(%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 0x7882
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7830
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5350
movq 0x41781(%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_O1/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 0x860c
movq %rbx, %rdi
callq 0x860c
movq %rsp, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5540
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x8079
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x825a
movq %rsp, %rdi
callq 0x50d0
movq %rsp, %rdi
callq 0x50f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq 0x40f70(%rip), %rdi     # 0x48ff0
leaq 0x2f6a9(%rip), %rsi     # 0x37730
movl $0x10, %edx
callq 0x53b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x40f51(%rip), %rdi     # 0x48ff0
callq 0x53b0
movq %rax, %rdi
callq 0x51a0
movl $0x1, %edi
callq 0x53e0
movq %rax, %r14
jmp 0x80c6
movq %rax, %r14
movq %rsp, %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x83c4
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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
setae %al
jb 0x1309a
movsd (%rdx), %xmm0
ucomisd 0x8(%rdx), %xmm0
ja 0x1309a
movl $0x2, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x13094
movsd -0x8(%rdx,%rax,8), %xmm0
leaq 0x1(%rax), %rsi
ucomisd (%rdx,%rax,8), %xmm0
jbe 0x1307b
cmpq %rax, %rcx
seta %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1312b
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x18(%rsp), %r12
movq (%rbx), %rcx
movsd (%rax,%r13,8), %xmm0
movsd (%rcx,%r13,8), %xmm1
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x1310a
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x13115
movq %r15, %rdi
movq %r12, %rdx
callq 0x14194
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x130d3
movq (%rsp), %r12
movq 0x8(%rsp), %r15
cmpq %r15, %r12
je 0x1319c
movq %r15, %rax
subq %r12, %rax
sarq $0x4, %rax
leaq 0x1(%rax), %rcx
shrq $0x3f, %rcx
leaq (%rax,%rcx), %rdx
incq %rdx
sarq %rdx
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x142d4
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x1317e
movq 0x20(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x143d2
jmp 0x13189
movq %r12, %rdi
movq %r15, %rsi
callq 0x14355
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
shlq $0x4, %rsi
callq 0x5350
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x131e4
sarq $0x4, %rax
movq (%r14), %rcx
movq (%rbx), %rdx
cmpq $0x1, %rax
adcq $0x0, %rax
leaq 0x8(%rdi), %rsi
xorl %r8d, %r8d
movsd -0x8(%rsi), %xmm0
movsd %xmm0, (%rcx,%r8,8)
movsd (%rsi), %xmm0
movsd %xmm0, (%rdx,%r8,8)
incq %r8
addq $0x10, %rsi
cmpq %r8, %rax
jne 0x131c3
testq %rdi, %rdi
je 0x131f6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
shlq $0x4, %rsi
callq 0x5350
jmp 0x13221
jmp 0x1321e
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13237
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5350
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x140be
leaq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x140be
movl 0x30(%r15), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r15), %rax
testq %rax, %rax
je 0x135f4
movq (%rax), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %r13
leaq 0x270f7(%rip), %rax     # 0x3a658
cmpq %rax, %r13
je 0x135ce
cmpb $0x2a, (%r13)
je 0x13580
leaq 0x270e4(%rip), %rsi     # 0x3a658
movq %r13, %rdi
callq 0x5490
testl %eax, %eax
je 0x135ce
leaq 0x270f4(%rip), %rax     # 0x3a67b
cmpq %rax, %r13
je 0x135a6
cmpb $0x2a, (%r13)
je 0x135ea
leaq 0x270e1(%rip), %rsi     # 0x3a67b
movq %r13, %rdi
callq 0x5490
testl %eax, %eax
jne 0x135ea
movl $0x30, %edi
callq 0x5340
movq %rax, %r13
leaq 0x352f6(%rip), %rax     # 0x488b0
movq %rax, (%r13)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x13a86
jmp 0x135e6
movl $0x8, %edi
callq 0x5340
movq %rax, %r13
leaq 0x352e6(%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 0x1360e
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13622
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13636
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1371c
movq %rsi, %r14
movq %rbx, %rdi
callq 0x140be
leaq 0x18(%r14), %r15
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x140be
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1372b
movq (%rax), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %r12
leaq 0x26fc5(%rip), %rax     # 0x3a658
cmpq %rax, %r12
je 0x13700
cmpb $0x2a, (%r12)
je 0x136b2
leaq 0x26fb2(%rip), %rsi     # 0x3a658
movq %r12, %rdi
callq 0x5490
testl %eax, %eax
je 0x13700
leaq 0x26fc2(%rip), %rax     # 0x3a67b
cmpq %rax, %r12
je 0x136d8
cmpb $0x2a, (%r12)
je 0x1371c
leaq 0x26faf(%rip), %rsi     # 0x3a67b
movq %r12, %rdi
callq 0x5490
testl %eax, %eax
jne 0x1371c
movl $0x30, %edi
callq 0x5340
movq %rax, %r12
leaq 0x351c4(%rip), %rax     # 0x488b0
movq %rax, (%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13a86
jmp 0x13718
movl $0x8, %edi
callq 0x5340
movq %rax, %r12
leaq 0x351b4(%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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13802
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 0x137db
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x137e8
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x7c14
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %rbp
cmpq %r12, %rax
ja 0x137a6
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 0x1382b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5350
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x138e5
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x1522a
cmpq $0x0, 0x8(%r14)
jle 0x138b4
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 0x138c6
movq (%rbx), %rax
movsd %xmm0, (%rax,%rbp)
incq %r12
addq $0x8, %rbp
cmpq %r12, 0x8(%r14)
jg 0x13880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26cc0(%rip), %rdi     # 0x3a58d
leaq 0x26cd6(%rip), %rsi     # 0x3a5aa
leaq 0x26cf6(%rip), %rcx     # 0x3a5d1
movl $0x198, %edx            # imm = 0x198
callq 0x5230
leaq 0x26a6e(%rip), %rdi     # 0x3a35a
leaq 0x26af1(%rip), %rsi     # 0x3a3e4
leaq 0x26b11(%rip), %rcx     # 0x3a40b
movl $0x138, %edx            # imm = 0x138
callq 0x5230
jmp 0x13906
movq %rax, %r14
movq (%rbx), %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34b2f(%rip), %rax     # 0x488b0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x13d92
callq 0x5410
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13da0
callq 0x5410
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x13dae
callq 0x5410
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x13dbd
popq %rbx
jmp 0x5410
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
leaq 0x34adb(%rip), %rax     # 0x488b0
movq %rax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movslq 0x8(%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%r14)
testq %r12, %r12
jle 0x13e21
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13e0f
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%r14)
testl %r12d, %r12d
jle 0x13e4a
movq 0x18(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13e38
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%r14)
testl %r12d, %r12d
jle 0x13e73
movq 0x20(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13e61
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%r14)
testl %r12d, %r12d
jle 0x13e9c
movq 0x28(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13e8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13f83
movq %rsi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
movslq 0x8(%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movq $-0x1, %r15
cmovnsq %rax, %r15
movq %r15, %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
testq %r12, %r12
jle 0x13f08
movq 0x10(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13ef6
movq %r15, %rdi
callq 0x5030
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
jle 0x13f31
movq 0x18(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13f1f
movq %r15, %rdi
callq 0x5030
movq %rax, 0x20(%rbx)
testl %r12d, %r12d
jle 0x13f5a
movq 0x20(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13f48
movq %r15, %rdi
callq 0x5030
movq %rax, 0x28(%rbx)
testl %r12d, %r12d
jle 0x13f83
movq 0x28(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x13f71
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq