LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .disable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x2bf7d0
cmpq %rax, %r14
je 0x2bec69
movl 0x40(%rax), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2bec69
addq $0x1c0, %rbx            # imm = 0x1C0
movl %eax, %eax
shlq $0x5, %rax
leaq 0x1720a9(%rip), %rsi    # 0x430d00
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1305b8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .disable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x2bf816
cmpq %rax, %r14
je 0x2becc1
movl 0x40(%rax), %eax
decl %eax
cmpl $0x7, %eax
ja 0x2becc1
addq $0x1f0, %rbx            # imm = 0x1F0
movl %eax, %eax
shlq $0x5, %rax
leaq 0x172111(%rip), %rsi    # 0x430dc0
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1305b8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .enable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x2bf78a
cmpq %rax, %r14
je 0x2bed02
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2bf85c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .enable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x2bf7d0
cmpq %rax, %r14
je 0x2bed42
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2bf8e6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .enable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x2bf816
cmpq %rax, %r14
je 0x2bed82
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2bf936
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_arithmetic_operation(exprtk::parser<double>::settings_store::settings_arithmetic_opr)
settings_store& enable_arithmetic_operation(const settings_arithmetic_opr arithmetic)
         {
            if (
                 (e_arith_unknown != arithmetic) &&
                 (static_cast<std::size_t>(arithmetic) < (details::arithmetic_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]);

               if (disabled_arithmetic_set_.end() != itr)
               {
                  disabled_arithmetic_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x2bf8a0
leaq 0xa0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1713c2(%rip), %rsi    # 0x430c40
addq %rax, %rsi
movq %r14, %rdi
callq 0x12d10c
leaq 0xa8(%rbx), %rcx
cmpq %rax, %rcx
je 0x2bf8a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2bf8ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_assignment_operation(exprtk::parser<double>::settings_store::settings_assignment_opr)
settings_store& enable_assignment_operation(const settings_assignment_opr assignment)
         {
            if (
                 (e_assign_unknown != assignment) &&
                 (static_cast<std::size_t>(assignment) < (details::assignment_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]);

               if (disabled_assignment_set_.end() != itr)
               {
                  disabled_assignment_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x2bf92a
leaq 0xd0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1713f8(%rip), %rsi    # 0x430d00
addq %rax, %rsi
movq %r14, %rdi
callq 0x12d10c
leaq 0xd8(%rbx), %rcx
cmpq %rax, %rcx
je 0x2bf92a
movq %r14, %rdi
movq %rax, %rsi
callq 0x2bf8ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_inequality_operation(exprtk::parser<double>::settings_store::settings_inequality_opr)
settings_store& enable_inequality_operation(const settings_inequality_opr inequality)
         {
            if (
                 (e_ineq_unknown != inequality) &&
                 (static_cast<std::size_t>(inequality) < (details::inequality_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]);

               if (disabled_inequality_set_.end() != itr)
               {
                  disabled_inequality_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x7, %esi
ja 0x2bf97a
leaq 0x100(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x171468(%rip), %rsi    # 0x430dc0
addq %rax, %rsi
movq %r14, %rdi
callq 0x12d10c
leaq 0x108(%rbx), %rcx
cmpq %rax, %rcx
je 0x2bf97a
movq %r14, %rdi
movq %rax, %rsi
callq 0x2bf8ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::setup_symbol_table()
void setup_symbol_table()
   {
      if (!persist_symbol_table_)
      {
         symbol_table_.clear_variables();
         symbol_table_.add_constants  ();
         symbol_table_.add_constant ("e", exprtk::details::numeric::constant::e);
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rdi)
jne 0x2bfad6
movq %rdi, %rbx
movq 0x10(%rdi), %rax
addq $0x10, %rbx
movq 0x8(%rax), %r14
cmpq $0x0, 0x28(%r14)
je 0x2bfa79
movq 0x18(%r14), %r15
leaq 0x8(%r14), %r12
cmpq %r15, %r12
je 0x2bfa71
movq 0x48(%r15), %rdi
movl $0x30, %esi
callq 0x11c0d0
movq %r15, %rdi
callq 0x11c5c0
movq %rax, %r15
cmpq %rax, %r12
jne 0x2bfa53
movq %r14, %rdi
callq 0x124994
movq $0x0, 0x30(%r14)
movq %rbx, %rdi
callq 0x123296
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x80a0(%rip), %rsi      # 0x2c7b39
leaq 0x809a(%rip), %rdx      # 0x2c7b3a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11fa26
leaq 0x25ff4(%rip), %rdx     # 0x2e5aa8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18b412
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bfad6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11c0d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bfafc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11c0d0
movq %rbx, %rdi
callq 0x11c3c0
// File: /workspace/github_cpp_makefile_star2_O3/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_almost_equal(double, double, double, int, char const*)
static void assert_almost_equal(double first, double second,
                                    double precision, int line_number,
                                    const char* assertion_text) {
      if (std::abs(first - second) <= precision) {
        return;
      }
      std::ostringstream reason;
      // For now, we'll just set the precision arbitrarily high.
      // In the future, we may decide to add an option to configure
      // the output precision.
      reason.precision(20);
      reason << "Values too far apart: " << first << " and " << second;
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
andpd 0xf797(%rip), %xmm3     # 0x15040
ucomisd %xmm3, %xmm2
jb 0x58bd
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movl %edi, %ebp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x43b0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x14, 0x38(%rsp,%rax)
leaq 0xf929(%rip), %rsi      # 0x1521b
movl $0x16, %edx
movq %r14, %rdi
callq 0x4340
leaq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0x4450
movq %rax, %r14
leaq 0xf919(%rip), %rsi      # 0x15232
movl $0x5, %edx
movq %rax, %rdi
callq 0x4340
movq %r14, %rdi
movsd 0x20(%rsp), %xmm0
callq 0x4450
movl $0x30, %edi
callq 0x4150
movq %rax, %r14
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x4440
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x5971
movupd (%r15), %xmm0
movupd %xmm0, (%rax)
jmp 0x597d
movq %rcx, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x180e9(%rip), %rsi     # 0x1da90
leaq -0x13e(%rip), %rdx      # 0x5870
movq %r14, %rdi
callq 0x44b0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x59e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x59e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
jmp 0x59e1
movq %rax, %rbx
movq 0x185b0(%rip), %rsi     # 0x1df98
leaq 0x30(%rsp), %rdi
callq 0x4180
leaq 0xa0(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x44d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: open_and_check_file(std::basic_ifstream<char, std::char_traits<char>>&, int*)
bool open_and_check_file(std::ifstream& f, int *filesize) {
    *filesize = get_file_size(f);

    char magic[4] = "";
    read_char(f, magic, 4);
    read_arbitrary<uint32_t>(f, 4); // version

    if (0 != std::strncmp("SNSS", magic, 4)) {
        std::cerr << "Error: Not a valid SNSS file." << std::endl;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4599
movl %eax, (%rbx)
leaq -0x14(%rbp), %rbx
movl $0x0, (%rbx)
movl $0x4, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3160
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x3160
movl (%rbx), %r14d
cmpl $0x53534e53, %r14d      # imm = 0x53534E53
je 0x465f
movq 0x59cc(%rip), %rbx      # 0x9ff0
leaq 0x1aca(%rip), %rsi      # 0x60f5
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x3150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
cmpl $0x53534e53, %r14d      # imm = 0x53534E53
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_session_file(std::basic_ifstream<char, std::char_traits<char>>&)
std::vector<std::shared_ptr<Command>> read_session_file(std::ifstream& f) {
    int filesize;
    if (!open_and_check_file(f, &filesize))
        return {};

    std::vector<std::shared_ptr<Command>> ret;

    while (f.tellg() < filesize) {
        std::shared_ptr<Command> c = read_next_session_command(f);
        ret.push_back(c);

        if (c->size == 0) {
            break;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x45ce
xorps %xmm0, %xmm0
testb %al, %al
je 0x46f1
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movslq -0x2c(%rbp), %r12
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x31f0
cmpq %r12, %rax
jge 0x46fc
movq %r15, %rdi
movq %r14, %rsi
callq 0x3609
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d32
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movzwl 0x8(%rax), %r13d
testq %rdi, %rdi
je 0x46e9
callq 0x4e72
testw %r13w, %r13w
jne 0x46af
jmp 0x46fc
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x4726
callq 0x4e72
jmp 0x4726
jmp 0x4723
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d80
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_session_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::shared_ptr<Command>> read_session_file(const std::string& filename) {
    std::ifstream f(filename, std::ios::binary | std::ios::in);
    if (!f.is_open() || f.fail()) {
        std::cerr << "Error while trying to open file " << filename << "." << std::endl;
        return {};
    }

    std::vector<std::shared_ptr<Command>> ret;
    ret = read_session_file(f);
    f.close();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x258(%rbp), %rdi
movl $0xc, %edx
callq 0x31b0
leaq -0x1e0(%rbp), %rdi
callq 0x3050
testb %al, %al
je 0x4784
movq -0x258(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x238(%rbp,%rax)
je 0x4816
movq 0x5865(%rip), %rdi      # 0x9ff0
leaq 0x1981(%rip), %rsi      # 0x6113
movl $0x20, %edx
callq 0x3150
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5846(%rip), %rdi      # 0x9ff0
callq 0x3150
movq %rax, %r14
leaq 0x1958(%rip), %rsi      # 0x6111
movl $0x1, %edx
movq %rax, %rdi
callq 0x3150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3120
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x258(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x30(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x4672
leaq -0x30(%rbp), %r14
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
leaq -0x50(%rbp), %rdi
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps %xmm0, (%r14)
movq %rax, 0x10(%r14)
callq 0x4d80
movq %r14, %rdi
callq 0x4d80
leaq -0x258(%rbp), %rdi
callq 0x3040
jmp 0x47fb
jmp 0x4886
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d80
jmp 0x4896
movq %rax, %r14
leaq -0x258(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_tabs_file(std::basic_ifstream<char, std::char_traits<char>>&)
std::vector<std::shared_ptr<Command>> read_tabs_file(std::ifstream& f) {
    int filesize;
    if (!open_and_check_file(f, &filesize))
        return {};

    std::vector<std::shared_ptr<Command>> ret;

    while (f.tellg() < filesize) {
        std::shared_ptr<Command> c = read_next_tab_command(f);
        ret.push_back(c);

        if (c->size == 0) {
            break;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x45ce
xorps %xmm0, %xmm0
testb %al, %al
je 0x4929
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movslq -0x2c(%rbp), %r12
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x31f0
cmpq %r12, %rax
jge 0x4934
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f90
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d32
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movzwl 0x8(%rax), %r13d
testq %rdi, %rdi
je 0x4921
callq 0x4e72
testw %r13w, %r13w
jne 0x48e7
jmp 0x4934
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x495e
callq 0x4e72
jmp 0x495e
jmp 0x495b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d80
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_tabs_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::shared_ptr<Command>> read_tabs_file(const std::string& filename) {
    std::ifstream f(filename, std::ios::binary | std::ios::in);
    if (!f.is_open() || f.fail()) {
        std::cerr << "Error while trying to open file " << filename << "." << std::endl;
        return {};
    }

    std::vector<std::shared_ptr<Command>> ret;
    ret = read_tabs_file(f);
    f.close();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x258(%rbp), %rdi
movl $0xc, %edx
callq 0x31b0
leaq -0x1e0(%rbp), %rdi
callq 0x3050
testb %al, %al
je 0x49bc
movq -0x258(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x238(%rbp,%rax)
je 0x4a4e
movq 0x562d(%rip), %rdi      # 0x9ff0
leaq 0x1749(%rip), %rsi      # 0x6113
movl $0x20, %edx
callq 0x3150
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x560e(%rip), %rdi      # 0x9ff0
callq 0x3150
movq %rax, %r14
leaq 0x1720(%rip), %rsi      # 0x6111
movl $0x1, %edx
movq %rax, %rdi
callq 0x3150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3120
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x258(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x30(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x48aa
leaq -0x30(%rbp), %r14
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
leaq -0x50(%rbp), %rdi
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps %xmm0, (%r14)
movq %rax, 0x10(%r14)
callq 0x4d80
movq %r14, %rdi
callq 0x4d80
leaq -0x258(%rbp), %rdi
callq 0x3040
jmp 0x4a33
jmp 0x4abe
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d80
jmp 0x4ace
movq %rax, %r14
leaq -0x258(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::MakeOutLinkCache()
void Species::MakeOutLinkCache() {
  if( m_cacheReady == false ) {
    m_outLinkCache.clear();
    for( auto s: m_outgoingInteractions ) {
      uint32_t t = s->m_immigrationTime;
      m_outLinkCache.push_back(t);
    }
    m_cacheReady = true;
  }
}

// Assembly:
cmpb $0x0, 0x88(%rdi)
je 0x2a24
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq %rax, 0x78(%rdi)
je 0x2a42
movq %rax, 0x78(%rbx)
movq 0x50(%rbx), %r14
leaq 0x40(%rbx), %r13
cmpq %r13, %r14
je 0x2a96
leaq 0x70(%rbx), %r15
leaq 0xc(%rsp), %r12
movq 0x20(%r14), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x78(%rbx), %rsi
cmpq 0x80(%rbx), %rsi
je 0x2a7b
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%rbx)
jmp 0x2a86
movq %r15, %rdi
movq %r12, %rdx
callq 0x4832
movq %r14, %rdi
callq 0x2250
movq %rax, %r14
cmpq %r13, %rax
jne 0x2a58
movb $0x1, 0x88(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Update()
void DynamicalGraph::Update() {
  int previous_diversity = Diversity();

  AddOneSpecies();
  Selection();

  int current_diversity = Diversity();
  int extinction_size = previous_diversity + 1 - current_diversity;

  // calculate histograms
  extinction_histo.Add( extinction_size );

  diversity_histo.Add( current_diversity );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
callq 0x3108
movq %rbx, %rdi
callq 0x32d2
testb %al, %al
jne 0x2f9e
leaq 0x38(%rbx), %rdi
callq 0x46da
movl 0x30(%rbx), %ebp
subl %ebp, %r14d
incl %r14d
leaq 0x78(%rbx), %rdi
movl %r14d, %esi
callq 0x3d2e
addq $0xa8, %rbx
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d2e
nop
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Selection()
void DynamicalGraph::Selection() {
  bool bNegativeExists = true;
  while(bNegativeExists) {
    bNegativeExists = RemoveNegativeFitnessSpecies();
  }

  m_dyingSpecies.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x32d2
testb %al, %al
jne 0x3186
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x46da
nop
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::AddRandomInteractions(Species*)
void DynamicalGraph::AddRandomInteractions(Species* s) {
  std::uniform_real_distribution<double> uniform(0.0,1.0);
  std::normal_distribution<double> nd;

  for( auto pSpecies : m_species ) {
    if( uniform(*pRnd) < m_connectance ) {
      s->MakeInteractionWith( pSpecies, nd(*pRnd) );
    }
    if( uniform(*pRnd) < m_connectance ) {
      pSpecies->MakeInteractionWith( s, nd(*pRnd) );
      if( pSpecies->IsGoingExtinct() ) { m_dyingSpecies.insert(pSpecies); }
    }
  }

  if( s->IsGoingExtinct() ) { m_dyingSpecies.insert(s); }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
xorpd %xmm0, %xmm0
movhpd 0x1e4b(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movq 0x20(%rdi), %r15
leaq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x329f
leaq 0x38(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %r13
movq 0x20(%r15), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rdi
callq 0x49e3
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3233
movq 0x8(%rsp), %rbp
movq 0x70(%rbx), %rsi
movq %r13, %rdi
movq %r13, %rdx
callq 0x4c74
movq %r14, %rdi
movq %rbp, %rsi
callq 0x247c
movq 0x70(%rbx), %rdi
callq 0x49e3
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x328b
movq 0x8(%rsp), %rbp
movq 0x70(%rbx), %rsi
movq %r13, %rdi
movq %r13, %rdx
callq 0x4c74
movq %rbp, %rdi
movq %r14, %rsi
callq 0x247c
movq 0x8(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x328b
cmpq $0x0, 0x30(%rax)
je 0x328b
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4784
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
cmpq %r12, %rax
jne 0x31f8
xorpd %xmm0, %xmm0
ucomisd 0x68(%r14), %xmm0
jbe 0x32c3
cmpq $0x0, 0x30(%r14)
je 0x32c3
addq $0x38, %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4784
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Extinct(Species*)
void DynamicalGraph::Extinct(Species* s) {
  s->DeleteInteractions(m_dyingSpecies);
  m_species.erase(s);

  int32_t lifetime = m_currentTime - s->ImmigrationTime();

  lifetime_histo.Add( lifetime );
  m_dyingSpecies.erase(s);

  delete s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %rsp, %rbx
movq %rsi, (%rbx)
leaq 0x38(%rdi), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x24e0
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x45dc
movq %r12, %rdi
movq %rax, %rsi
callq 0x4668
movl 0x68(%r15), %esi
movq (%rbx), %rax
subl (%rax), %esi
addq $0xd8, %r15
movq %r15, %rdi
callq 0x3d2e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45dc
movq %r14, %rdi
movq %rax, %rsi
callq 0x4668
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x33d0
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x33be
callq 0x21e0
leaq 0x38(%rbx), %rdi
callq 0x403a
leaq 0x8(%rbx), %rdi
callq 0x4326
movq %rbx, %rdi
callq 0x21e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::AverageDiversity() const
double DynamicalGraph::AverageDiversity() const {
  uint64_t sum = 0;
  uint64_t count = 0;
  for( auto key_freq : diversity_histo.histo ) {
    sum += key_freq.first * key_freq.second;
    count += key_freq.second;
  }
  return static_cast<double>(sum)/count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
addq $0xb0, %rbx
cmpq %rbx, %rax
je 0x360f
xorl %r15d, %r15d
xorl %r14d, %r14d
movl 0x24(%rax), %ecx
movl 0x20(%rax), %edx
imull %ecx, %edx
addq %rdx, %r15
addq %rcx, %r14
movq %rax, %rdi
callq 0x2250
cmpq %rbx, %rax
jne 0x35ab
movq %r15, %xmm1
movq 0x1a6c(%rip), %xmm2     # 0x5040
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1a70(%rip), %xmm3     # 0x5050
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x3617
movsd 0x1a01(%rip), %xmm0     # 0x5018
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Histogram::Add(unsigned int)
void Add( uint32_t x ) {
    if( histo.find(x) != histo.end() ) {
      histo[x] += 1;
    }
    else {
      histo[x] = 1;
    }
  }

// Assembly:
pushq %rax
movl %esi, 0x4(%rsp)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3d65
leaq 0x8(%rdi), %rdx
movq %rdx, %rcx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rax)
setb %r8b
cmovaeq %rax, %rcx
movq 0x10(%rax,%r8,8), %rax
testq %rax, %rax
jne 0x3d43
cmpq %rdx, %rcx
je 0x3d65
cmpl %esi, 0x20(%rcx)
jbe 0x3d77
leaq 0x4(%rsp), %rsi
callq 0x40c6
movl $0x1, (%rax)
popq %rax
retq
leaq 0x4(%rsp), %rsi
callq 0x40c6
incl (%rax)
jmp 0x3d75
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::Clear()
void TiXmlNode::Clear()
{
	TiXmlNode* node = firstChild;
	TiXmlNode* temp = 0;

	while ( node )
	{
		temp = node;
		node = node->next;
		delete temp;
	}	

	firstChild = 0;
	lastChild = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq $0x28, %rbx
testq %rdi, %rdi
je 0x369e
movq (%rdi), %rax
movq 0x48(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0x368c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::LinkEndChild(TiXmlNode*)
TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
{
	assert( node->parent == 0 || node->parent == this );
	assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );

	if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		delete node;
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	node->parent = this;

	node->prev = lastChild;
	node->next = 0;

	if ( lastChild )
		lastChild->next = node;
	else
		firstChild = node;			// it was an empty list.

	lastChild = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
setne %cl
cmpq %rdi, %rax
setne %al
testb %al, %cl
jne 0x3810
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x36ef
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x36d6
jmp 0x3761
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3761
xorl %r15d, %r15d
movq %r14, %r12
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x371e
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x3703
jmp 0x372b
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
movq %rax, %r15
xorl %r12d, %r12d
movq %rbx, %r13
movq (%r13), %rax
movq %r13, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x374b
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x3731
jmp 0x3758
movq (%r13), %rax
movq %r13, %rdi
callq *0x20(%rax)
movq %rax, %r12
cmpq %r12, %r15
jne 0x382f
cmpl $0x0, 0x20(%r14)
je 0x3794
movq %rbx, 0x18(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x40(%r14)
movq $0x0, 0x48(%r14)
leaq 0x28(%rbx), %rcx
leaq 0x48(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r14, (%rdx)
movq %r14, 0x30(%rbx)
jmp 0x3803
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %r14d, %r14d
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x37bc
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x37a3
jmp 0x3803
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3800
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x37de
movq 0x18(%rbx), %rbx
jmp 0x37ca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %r14d, %r14d
movq %rax, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
jmp 0x3803
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x67f6(%rip), %rdi      # 0xa00d
leaq 0x6819(%rip), %rsi      # 0xa037
leaq 0x681e(%rip), %rcx      # 0xa043
movl $0xbc, %edx
callq 0x30e0
leaq 0x683d(%rip), %rdi      # 0xa073
leaq 0x67fa(%rip), %rsi      # 0xa037
leaq 0x67ff(%rip), %rcx      # 0xa043
movl $0xbd, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertEndChild(TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
{
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}
	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;

	return LinkEndChild( node );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0x387e
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x38d9
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36ac
movq %rbx, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x389a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3881
jmp 0x38d9
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x38d9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x38bc
movq 0x18(%rbx), %rbx
jmp 0x38a8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertBeforeChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis )
{	
	if ( !beforeThis || beforeThis->parent != this ) {
		return 0;
	}
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;
	node->parent = this;

	node->next = beforeThis;
	node->prev = beforeThis->prev;
	if ( beforeThis->prev )
	{
		beforeThis->prev->next = node;
	}
	else
	{
		assert( firstChild == beforeThis );
		firstChild = node;
	}
	beforeThis->prev = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x38fa
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x18(%rsi)
je 0x3906
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x393b
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x38fa
movq %rax, %r14
movq %rbx, 0x18(%rax)
movq %r15, 0x48(%rax)
movq 0x40(%r15), %rax
movq %rax, 0x40(%r14)
testq %rax, %rax
je 0x397c
addq $0x48, %rax
jmp 0x3989
xorl %r14d, %r14d
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x395a
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3941
jmp 0x38fd
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x38fa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3995
movq 0x18(%rbx), %rbx
jmp 0x3968
cmpq %r15, 0x28(%rbx)
jne 0x39ba
addq $0x28, %rbx
movq %rbx, %rax
movq %r14, (%rax)
movq %r14, 0x40(%r15)
jmp 0x38fd
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %r14d, %r14d
movq %rax, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
jmp 0x38fd
leaq 0x66f9(%rip), %rdi      # 0xa0ba
leaq 0x666f(%rip), %rsi      # 0xa037
leaq 0x6704(%rip), %rcx      # 0xa0d3
movl $0xff, %edx
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertAfterChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
{
	if ( !afterThis || afterThis->parent != this ) {
		return 0;
	}
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;
	node->parent = this;

	node->prev = afterThis;
	node->next = afterThis->next;
	if ( afterThis->next )
	{
		afterThis->next->prev = node;
	}
	else
	{
		assert( lastChild == afterThis );
		lastChild = node;
	}
	afterThis->next = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x39f0
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x18(%rsi)
je 0x39fc
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x3a31
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x39f0
movq %rax, %r14
movq %rbx, 0x18(%rax)
movq %r15, 0x40(%rax)
movq 0x48(%r15), %rax
movq %rax, 0x48(%r14)
testq %rax, %rax
je 0x3a72
addq $0x40, %rax
jmp 0x3a7f
xorl %r14d, %r14d
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3a50
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3a37
jmp 0x39f3
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x39f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3a8b
movq 0x18(%rbx), %rbx
jmp 0x3a5e
cmpq %r15, 0x30(%rbx)
jne 0x3ab0
addq $0x30, %rbx
movq %rbx, %rax
movq %r14, (%rax)
movq %r14, 0x48(%r15)
jmp 0x39f3
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %r14d, %r14d
movq %rax, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
jmp 0x39f3
leaq 0x6664(%rip), %rdi      # 0xa11b
leaq 0x6579(%rip), %rsi      # 0xa037
leaq 0x666d(%rip), %rcx      # 0xa132
movl $0x120, %edx            # imm = 0x120
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::ReplaceChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis )
{
	if ( !replaceThis )
		return 0;

	if ( replaceThis->parent != this )
		return 0;

	if ( withThis.ToDocument() ) {
		// A document can never be a child.	Thanks to Noam.
		TiXmlDocument* document = GetDocument();
		if ( document ) 
			document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = withThis.Clone();
	if ( !node )
		return 0;

	node->next = replaceThis->next;
	node->prev = replaceThis->prev;

	if ( replaceThis->next )
		replaceThis->next->prev = node;
	else
		lastChild = node;

	if ( replaceThis->prev )
		replaceThis->prev->next = node;
	else
		firstChild = node;

	delete replaceThis;
	node->parent = this;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x3ae6
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, 0x18(%rsi)
je 0x3af1
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3b1d
xorl %ebx, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3b50
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3b04
jmp 0x3ae8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x3ae6
movq %rax, %rbx
movq 0x48(%r15), %rcx
movq %rcx, 0x48(%rax)
movq 0x40(%r15), %rax
movq %rax, 0x40(%rbx)
testq %rcx, %rcx
je 0x3b79
movq %rbx, 0x40(%rcx)
movq 0x40(%r15), %rax
jmp 0x3b7d
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3ae6
xorl %ebx, %ebx
movq %rax, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x768c
jmp 0x3ae8
movq %rbx, 0x30(%r14)
leaq 0x48(%rax), %rcx
leaq 0x28(%r14), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %rbx, (%rcx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r14, 0x18(%rbx)
jmp 0x3ae8
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::RemoveChild(TiXmlNode*)
bool TiXmlNode::RemoveChild( TiXmlNode* removeThis )
{
	if ( !removeThis ) {
		return false;
	}

	if ( removeThis->parent != this )
	{	
		assert( 0 );
		return false;
	}

	if ( removeThis->next )
		removeThis->next->prev = removeThis->prev;
	else
		lastChild = removeThis->prev;

	if ( removeThis->prev )
		removeThis->prev->next = removeThis->next;
	else
		firstChild = removeThis->next;

	delete removeThis;
	return true;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3be6
cmpq %rdi, 0x18(%rbx)
jne 0x3bee
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
leaq 0x30(%rdi), %rdx
leaq 0x40(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rdx, %rsi
movq %rax, (%rsi)
leaq 0x48(%rax), %rdx
addq $0x28, %rdi
testq %rax, %rax
cmovneq %rdx, %rdi
movq %rcx, (%rdi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testq %rbx, %rbx
setne %al
popq %rbx
retq
leaq 0x6584(%rip), %rdi      # 0xa179
leaq 0x643b(%rip), %rsi      # 0xa037
leaq 0x6578(%rip), %rcx      # 0xa17b
movl $0x157, %edx            # imm = 0x157
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement(char const*) const
const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const
{
	const TiXmlNode* node;
	for ( node = firstChild; node; node = node->next )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3ecf
movq %rsi, %r14
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3ef6
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
jne 0x3eb2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3ecf
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3ed9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3ed9
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::LastChild(char const*) const
const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
{
	const TiXmlNode* node;
	for ( node = lastChild; node; node = node->prev )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rbx
testq %rbx, %rbx
je 0x3c75
movq %rsi, %r14
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3c77
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x3c58
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::IterateChildren(TiXmlNode const*) const
const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
{
	if ( !previous )
	{
		return FirstChild();
	}
	else
	{
		assert( previous->parent == this );
		return previous->NextSibling();
	}
}

// Assembly:
testq %rsi, %rsi
je 0x3c96
cmpq %rdi, 0x18(%rsi)
jne 0x3c9e
addq $0x48, %rsi
movq %rsi, %rdi
jmp 0x3c9a
addq $0x28, %rdi
movq (%rdi), %rax
retq
pushq %rax
leaq 0x64fe(%rip), %rdi      # 0xa1a4
leaq 0x638a(%rip), %rsi      # 0xa037
leaq 0x6509(%rip), %rcx      # 0xa1bd
movl $0x189, %edx            # imm = 0x189
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::IterateChildren(char const*, TiXmlNode const*) const
const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
{
	if ( !previous )
	{
		return FirstChild( val );
	}
	else
	{
		assert( previous->parent == this );
		return previous->NextSibling( val );
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdx, %rdx
je 0x3cf2
movq %rdx, %rbx
cmpq %rdi, 0x18(%rdx)
jne 0x3d22
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3d15
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3cd3
jmp 0x3d17
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3d15
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3d17
movq 0x48(%rbx), %rbx
jmp 0x3cf6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x647b(%rip), %rdi      # 0xa1a4
leaq 0x6307(%rip), %rsi      # 0xa037
leaq 0x64cb(%rip), %rcx      # 0xa202
movl $0x197, %edx            # imm = 0x197
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::RemoveAttribute(char const*)
void TiXmlElement::RemoveAttribute( const char * name )
{
    #ifdef TIXML_USE_STL
	TIXML_STRING str( name );
	TiXmlAttribute* node = attributeSet.Find( str );
	#else
	TiXmlAttribute* node = attributeSet.Find( name );
	#endif
	if ( node )
	{
		attributeSet.Remove( node );
		delete node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x50, %r14
movq %r14, %rbx
movq 0x38(%rbx), %rbx
cmpq %r14, %rbx
je 0x3dee
movq 0x20(%rbx), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
jne 0x3db8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e2c
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::Remove(TiXmlAttribute*)
void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
{
	TiXmlAttribute* node;

	for( node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( node == removeMe )
		{
			node->prev->next = node->next;
			node->next->prev = node->prev;
			node->next = 0;
			node->prev = 0;
			return;
		}
	}
	assert( 0 );		// we tried to remove a non-linked attribute.
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq 0x38(%rax), %rax
cmpq %rdi, %rax
je 0x3e57
cmpq %rsi, %rax
jne 0x3e30
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%rcx)
movq %rcx, 0x30(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
popq %rax
retq
leaq 0x631b(%rip), %rdi      # 0xa179
leaq 0x61d2(%rip), %rsi      # 0xa037
leaq 0x667c(%rip), %rcx      # 0xa4e8
movl $0x608, %edx            # imm = 0x608
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement() const
const TiXmlElement* TiXmlNode::FirstChildElement() const
{
	const TiXmlNode* node;

	for (	node = FirstChild();
			node;
			node = node->NextSibling() )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x3e94
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3e98
movq 0x48(%rbx), %rbx
jmp 0x3e7b
xorl %eax, %eax
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSiblingElement() const
const TiXmlElement* TiXmlNode::NextSiblingElement() const
{
	const TiXmlNode* node;

	for (	node = NextSibling();
			node;
			node = node->NextSibling() )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3f39
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3f18
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
xorl %eax, %eax
popq %rbx
retq
nop