LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e431f
movq %rdi, %rbx
movq 0x10(%rdi), %rax
addq $0x10, %rbx
movq 0x8(%rax), %r14
cmpq $0x0, 0x28(%r14)
je 0x2e42c2
movq 0x18(%r14), %r15
leaq 0x8(%r14), %r12
cmpq %r15, %r12
je 0x2e42ba
movq 0x48(%r15), %rdi
testq %rdi, %rdi
je 0x2e42aa
movl $0x30, %esi
callq 0x11e0d0
movq %r15, %rdi
callq 0x11e5c0
movq %rax, %r15
cmpq %rax, %r12
jne 0x2e4297
movq %r14, %rdi
callq 0x12696c
movq $0x0, 0x30(%r14)
movq %rbx, %rdi
callq 0x125252
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x77ef(%rip), %rsi      # 0x2ebad1
leaq 0x77e9(%rip), %rdx      # 0x2ebad2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x121a7e
leaq 0x2576b(%rip), %rdx     # 0x309a68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3fec
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e431f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e4345
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0d0
movq %rbx, %rdi
callq 0x11e3c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf7ad(%rip), %xmm3     # 0x15040
ucomisd %xmm3, %xmm2
jb 0x58a7
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 0xf93f(%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 0xf92f(%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 0x595b
movupd (%r15), %xmm0
movupd %xmm0, (%rax)
jmp 0x5967
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 0x180cf(%rip), %rsi     # 0x1da60
leaq -0x13e(%rip), %rdx      # 0x585a
movq %r14, %rdi
callq 0x44b0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x59b9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
xorl %eax, %eax
jmp 0x59c2
movq %rax, %rbx
movb $0x1, %al
testb %al, %al
je 0x59d3
movq %r14, %rdi
callq 0x4230
jmp 0x59d3
movq %rax, %rbx
movq 0x185be(%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_O1/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_string(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
bool read_string(std::ifstream& f, std::string& ret, bool terminate) {
    uint32_t len = read_arbitrary<uint32_t>(f, 4);
    int start = f.tellg();
    int end = start + len;
    ret.resize(end - start);
    f.read(&ret[0], end - start);
    if (terminate) {
        uint16_t z = read_arbitrary<uint16_t>(f, 1);
        // For whatever reason the string is padded with an arbitrary amount of zeroes
        if (0 != z)
            return false; // If there is no zero, a string16 won't follow
        int count = 0;
        while (0 == z) {
            count += 1;
            z = read_arbitrary<uint16_t>(f, 1);
        }
        if (count > 3)
            return false;
        f.seekg(f.tellg() - 1L);

    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %r12
movl $0x4, %edx
movq %r12, %rsi
callq 0x3160
movslq (%r12), %r12
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3080
movq (%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3160
movb $0x1, %r14b
testl %r15d, %r15d
je 0x3473
leaq -0x24(%rbp), %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3160
cmpw $0x0, (%r15)
jne 0x3470
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq -0x22(%rbp), %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3160
incl %r12d
cmpw $0x0, -0x22(%rbp)
je 0x343a
cmpl $0x2, %r12d
ja 0x3470
movq %rbx, %rdi
callq 0x31f0
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x3170
jmp 0x3473
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_string16[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&, bool)
std::wstring read_string16(std::ifstream& f, bool terminate) {
    uint32_t len = read_arbitrary<uint32_t>(f, 4) * 2; // *2 because UTF-16
#ifdef DEBUG
    std::cout << "Reading string16: " << std::endl;
    std::cout << std::dec << len << std::endl;
    std::cout << std::hex << f.tellg() << std::endl;
    std::cout << std::dec;
#endif
    char tmp[len];
    read_char(f, tmp, len);
    if (terminate) {
        read_arbitrary<uint16_t>(f, 1); // String is null terminated with 0x00
    }

    if (len % 2) { len--; }
    std::wstring ret;
    for (size_t i = 0; i < len;) {
        // little-endian
        int lo = tmp[i++] & 0xFF;
        int hi = tmp[i++] & 0xFF;
        ret.push_back(hi << 8 | lo);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movl $0x4, %edx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3160
movl (%r14), %r13d
addl %r13d, %r13d
movq %rsp, %r14
leaq 0xf(%r13), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movslq %r13d, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3160
testl %r12d, %r12d
je 0x34e9
leaq -0x2a(%rbp), %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x3160
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
testq %r13, %r13
je 0x351d
xorl %r12d, %r12d
movzwl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x30a0
addq $0x2, %r12
cmpq %r13, %r12
jb 0x3507
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x354a
movq (%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x3140
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: get_file_size(std::basic_ifstream<char, std::char_traits<char>>&)
int get_file_size(std::ifstream& f) {
    f.seekg(0, std::ios::end);
    int filesize = f.tellg();
    f.seekg(0);
    return filesize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x2, %edx
callq 0x3180
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3170
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47bc
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 0x4882
movq 0x57a9(%rip), %rbx      # 0x9ff0
leaq 0x18c3(%rip), %rsi      # 0x6111
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_O1/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 0x47f1
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testb %al, %al
je 0x4912
movslq -0x2c(%rbp), %r12
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x31f0
cmpq %r12, %rax
jge 0x4912
movq %r15, %rdi
movq %r14, %rsi
callq 0x3609
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f76
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movzwl 0x8(%rax), %r13d
testq %rdi, %rdi
je 0x490c
callq 0x50a8
testw %r13w, %r13w
jne 0x48d2
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 0x493c
callq 0x50a8
jmp 0x493c
jmp 0x4939
movq %rax, %r14
movq %rbx, %rdi
callq 0x4fbc
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x240, %rsp            # imm = 0x240
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x248(%rbp), %rdi
movl $0xc, %edx
callq 0x31b0
leaq -0x1d0(%rbp), %rdi
callq 0x3050
testb %al, %al
je 0x499a
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0x4a2c
movq 0x564f(%rip), %rdi      # 0x9ff0
leaq 0x1787(%rip), %rsi      # 0x612f
movl $0x20, %edx
callq 0x3150
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5630(%rip), %rdi      # 0x9ff0
callq 0x3150
movq %rax, %r14
leaq 0x175e(%rip), %rsi      # 0x612d
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 -0x248(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x4895
leaq -0x40(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rax
movups 0x8(%rbx), %xmm0
leaq -0x28(%rbp), %r14
movq (%r14), %rcx
movq %rcx, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r14)
movq %rdx, 0x8(%r14)
movq %rsi, 0x10(%r14)
callq 0x4fbc
movq %r14, %rdi
callq 0x4fbc
leaq -0x248(%rbp), %rdi
callq 0x3040
jmp 0x4a11
jmp 0x4aba
movq %rax, %r14
movq %rbx, %rdi
callq 0x4fbc
jmp 0x4aca
movq %rax, %r14
leaq -0x248(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47f1
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testb %al, %al
je 0x4b5b
movslq -0x2c(%rbp), %r12
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x31f0
cmpq %r12, %rax
jge 0x4b5b
movq %r15, %rdi
movq %r14, %rsi
callq 0x40fb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f76
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movzwl 0x8(%rax), %r13d
testq %rdi, %rdi
je 0x4b55
callq 0x50a8
testw %r13w, %r13w
jne 0x4b1b
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 0x4b85
callq 0x50a8
jmp 0x4b85
jmp 0x4b82
movq %rax, %r14
movq %rbx, %rdi
callq 0x4fbc
movq %r14, %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::MakeInteractionWith(Species*, double)
void Species::MakeInteractionWith(Species* other, double coefficient) {
  m_incomingInteractions.insert( std::make_pair(other, coefficient) );
  m_fitness += coefficient;
  other->m_outgoingInteractions.insert(this);
  other->m_cacheReady = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
leaq 0x10(%rsp), %r15
movq %rsi, (%r15)
movsd %xmm0, 0x8(%r15)
movq %r15, %rsi
callq 0x4388
movsd 0x8(%rsp), %xmm0
addsd 0x68(%r14), %xmm0
movsd %xmm0, 0x68(%r14)
leaq 0x38(%rbx), %rdi
movq %r14, (%r15)
leaq 0x10(%rsp), %rsi
callq 0x44da
movb $0x0, 0x88(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::DeleteInteractions(std::set<Species*, Species::comp, std::allocator<Species*>>&)
void Species::DeleteInteractions( SpeciesSet& dyingSpecies) {
  for( auto pair : m_incomingInteractions ) {
    pair.first->m_outgoingInteractions.erase(this);
    pair.first->m_cacheReady = false;
  }
  for( auto other : m_outgoingInteractions ) {
    auto found = other->m_incomingInteractions.find(this);
    other->m_fitness -= found->second;
    other->m_incomingInteractions.erase(found);

    if( other->IsGoingExtinct() ) {
      dyingSpecies.insert(other);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x20(%rdi), %r15
leaq 0x10(%rdi), %rbp
cmpq %rbp, %r15
je 0x253f
movq %rsp, %r12
movq 0x20(%r15), %rbx
leaq 0x38(%rbx), %r13
movq %r14, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x45f8
movq %r13, %rdi
movq %rax, %rsi
callq 0x467e
movb $0x0, 0x88(%rbx)
movq %r15, %rdi
callq 0x2150
movq %rax, %r15
cmpq %rbp, %rax
jne 0x2506
movq 0x50(%r14), %r15
leaq 0x40(%r14), %rbp
cmpq %rbp, %r15
movq 0x8(%rsp), %rbx
je 0x25c2
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movq 0x20(%r15), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
movq %r14, 0x10(%rsp)
movq %r12, %rsi
callq 0x471e
movq (%rsp), %rdi
movsd 0x68(%rdi), %xmm0
subsd 0x28(%rax), %xmm0
movsd %xmm0, 0x68(%rdi)
addq $0x8, %rdi
movq %rax, %rsi
callq 0x476a
movq (%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x25b2
cmpq $0x0, 0x30(%rax)
je 0x25b2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x47a2
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
cmpq %rbp, %rax
jne 0x2559
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::ToString[abi:cxx11]()
std::string Species::ToString() {
  std::ostringstream oss;
  oss << "immigrationTime: " << m_immigrationTime << std::endl;
  oss << "incoming:" << std::endl;
  for( auto pair : m_incomingInteractions ) {
    oss << "  " << pair.first << ", " << pair.second << std::endl;
  }
  return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2280
leaq 0x2a97(%rip), %rsi      # 0x50ac
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2240
movl (%r14), %esi
leaq 0x10(%rsp), %rdi
callq 0x2130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x2a5e(%rip), %rsi      # 0x50be
leaq 0x10(%rsp), %rbx
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2240
movq 0x10(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
leaq 0x10(%rsp), %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %r12, (%rsp)
movq 0x20(%r14), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x274f
leaq 0x2a0f(%rip), %r12      # 0x50c8
leaq 0x10(%rsp), %r13
leaq 0x2a06(%rip), %rbp      # 0x50cb
movq 0x20(%r15), %rbx
movsd 0x28(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2170
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2240
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x22f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %r15, %rdi
callq 0x2150
movq %rax, %r15
cmpq %r14, %rax
jne 0x26c5
leaq 0x18(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x22e0
movq 0x5869(%rip), %rsi      # 0x7fd0
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x80(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2795
movq %rax, %rbx
movq 0x5831(%rip), %rsi      # 0x7fd0
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x80(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a1e
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 0x2a3c
movq %rax, 0x78(%rbx)
movq 0x50(%rbx), %r14
leaq 0x40(%rbx), %r13
cmpq %r13, %r14
je 0x2a90
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 0x2a75
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%rbx)
jmp 0x2a80
movq %r15, %rdi
movq %r12, %rdx
callq 0x4850
movq %r14, %rdi
callq 0x2250
movq %rax, %r14
cmpq %r13, %rax
jne 0x2a52
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_O1/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 0x3100
movq %rbx, %rdi
callq 0x32d6
testb %al, %al
jne 0x2f98
leaq 0x38(%rbx), %rdi
callq 0x46f0
movl 0x30(%rbx), %ebp
subl %ebp, %r14d
incl %r14d
leaq 0x78(%rbx), %rdi
movl %r14d, %esi
callq 0x3d38
addq $0xa8, %rbx
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d38
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32d6
testb %al, %al
jne 0x317e
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x46f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq %rsi, 0x10(%rsp)
xorpd %xmm0, %xmm0
movhpd 0x1e56(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x329e
leaq 0x38(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %r12
movq 0x20(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rdi
callq 0x4a01
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x322d
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %r13
movq 0x70(%rbx), %rsi
movq %r12, %rdi
movq %r12, %rdx
callq 0x4c8e
movq %rbp, %rdi
movq %r13, %rsi
callq 0x247c
movq 0x70(%rbx), %rdi
callq 0x4a01
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x328a
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %rbp
movq 0x70(%rbx), %rsi
movq %r12, %rdi
movq %r12, %rdx
callq 0x4c8e
movq %r13, %rdi
movq %rbp, %rsi
callq 0x247c
movq 0x8(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x328a
cmpq $0x0, 0x30(%rax)
je 0x328a
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x47a2
movq %r14, %rdi
callq 0x2250
movq %rax, %r14
cmpq %r15, %rax
jne 0x31ed
movq 0x10(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x32c6
cmpq $0x0, 0x30(%rax)
je 0x32c6
addq $0x38, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x47a2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::RemoveNegativeFitnessSpecies()
bool DynamicalGraph::RemoveNegativeFitnessSpecies() {
  // remove negative fitness species
  // Find minimum
  Species* pMinSpecies = NULL;
  double min = 0.0;
  for( auto pSpecies : m_dyingSpecies ) {
    double f = pSpecies->Fitness();
    if( min > f ) {
      min = f;
      pMinSpecies = pSpecies;
    }
  }
  if( pMinSpecies != NULL ) {
    Extinct(pMinSpecies);
  }
  return (pMinSpecies != NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
leaq 0x40(%rdi), %r15
cmpq %r15, %rax
je 0x3326
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movq 0x20(%rax), %rcx
movsd 0x68(%rcx), %xmm1
ucomisd %xmm1, %xmm0
minsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
cmovaq %rcx, %r14
movq %rax, %rdi
callq 0x2250
movsd 0x8(%rsp), %xmm0
cmpq %r15, %rax
jne 0x32f6
jmp 0x3329
xorl %r14d, %r14d
testq %r14, %r14
je 0x3339
movq %rbx, %rdi
movq %r14, %rsi
callq 0x334a
testq %r14, %r14
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f8
movq %r12, %rdi
movq %rax, %rsi
callq 0x467e
movl 0x68(%r15), %esi
movq (%rbx), %rax
subl (%rax), %esi
addq $0xd8, %r15
movq %r15, %rdi
callq 0x3d38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45f8
movq %r14, %rdi
movq %rax, %rsi
callq 0x467e
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x33e2
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x33c8
callq 0x21e0
leaq 0x38(%rbx), %rdi
callq 0x4052
leaq 0x8(%rbx), %rdi
callq 0x433e
movq %rbx, %rdi
callq 0x21e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3619
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 0x35b5
movq %r15, %xmm1
movq 0x1a62(%rip), %xmm2     # 0x5040
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1a66(%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 0x3621
movsd 0x19f7(%rip), %xmm0     # 0x5018
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq 0x10(%rdi), %rcx
leaq 0x8(%rdi), %rbx
movq %rbx, %rax
testq %rcx, %rcx
je 0x3d69
movq %rbx, %rax
xorl %edx, %edx
cmpl %esi, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x3d53
movq %rbx, %r14
cmpq %rbx, %rax
je 0x3d7b
cmpl %esi, 0x20(%rax)
cmovaq %rbx, %rax
movq %rax, %r14
leaq 0x4(%rsp), %rsi
callq 0x40de
movl (%rax), %ecx
incl %ecx
cmpq %rbx, %r14
movl $0x1, %edx
cmovnel %ecx, %edx
movl %edx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/noizebox[P]zipfsong/zipfsong_cpp_fast.cpp
// Function: parse_songs(int, std::vector<Song, std::allocator<Song>>&, char*, unsigned long)
void parse_songs(const int songs, std::vector<Song>& song_list, char* mem, size_t mem_size)
{
    song_list.reserve(songs);
    std::cin.read(mem, mem_size);

    const char* c = mem;
    const char* end = mem + mem_size;
    std::string_view plays;
    int song_pos = 1;
    int str_len = 0;

    while (song_pos <= songs && ++c < end)
    {
        if (*c == ' ')
        {
            plays = std::string_view(c - str_len, str_len);
            str_len = 0;
            ++c;
        }
        else if (*c == '\n')
        {
            auto listens = unsafe_strtol(plays);
            auto title = std::string_view(c - str_len, str_len);
            song_list.emplace_back(title, listens * song_pos++);
            str_len = 0;
            ++c;    
        }
        ++str_len;
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %edi, %ebp
movslq %edi, %r12
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
movq %r12, %rsi
callq 0x177a
movq 0x3cc4(%rip), %rdi      # 0x4fe0
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1110
testl %r12d, %r12d
jle 0x13db
addq %r15, %rbx
movl $0x1, %r12d
xorl %eax, %eax
xorl %r13d, %r13d
xorl %r14d, %r14d
leaq 0x1(%r15), %rcx
cmpq %rbx, %rcx
jae 0x13db
movzbl (%rcx), %edx
cmpl $0xa, %edx
je 0x136c
cmpl $0x20, %edx
jne 0x13cd
movslq %eax, %r13
subq %r13, %rcx
addq $0x2, %r15
xorl %eax, %eax
movq %rcx, %r14
jmp 0x13ca
testq %r13, %r13
je 0x1390
xorl %esi, %esi
xorl %edx, %edx
movsbq (%r14,%rsi), %rdi
leaq (%rdx,%rdx,4), %rdx
leaq (%rdi,%rdx,2), %rdx
addq $-0x30, %rdx
incq %rsi
cmpq %rsi, %r13
jne 0x1375
jmp 0x1392
xorl %edx, %edx
cltq
subq %rax, %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movslq %r12d, %rax
incl %r12d
imulq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x183e
addq $0x2, %r15
xorl %eax, %eax
movq %r15, %rcx
incl %eax
movq %rcx, %r15
cmpl %ebp, %r12d
jle 0x1341
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlBase::EncodeString(TiXmlString const&, TiXmlString*)
TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase()
{
	parent = 0;
	type = _type;
	firstChild = 0;
	lastChild = 0;
	prev = 0;
	next = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq (%rax), %rdx
testl %edx, %edx
jle 0x35bc
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xcd25(%rip), %r13      # 0x10180
movq %rsp, %r12
movq %rdx, %rsi
xorl %r15d, %r15d
movslq %r15d, %rbp
cmpq %rbp, %rsi
jbe 0x35cb
movb 0x10(%rax,%rbp), %dil
movzbl %dil, %ecx
cmpl $0x26, %ecx
jle 0x34a6
cmpl $0x27, %ecx
je 0x3538
cmpl $0x3c, %ecx
je 0x3542
cmpl $0x3e, %ecx
jne 0x3556
movq 0x20(%r13), %rsi
movl 0x28(%r13), %edx
jmp 0x3587
cmpl $0x22, %ecx
je 0x354c
cmpl $0x26, %ecx
jne 0x3556
addl $-0x2, %edx
cmpl %edx, %r15d
jge 0x357f
leaq 0x1(%rbp), %rcx
cmpq %rcx, %rsi
jbe 0x35cb
cmpb $0x23, 0x10(%rax,%rcx)
jne 0x357f
leaq 0x2(%rbp), %rcx
cmpq %rcx, %rsi
jbe 0x35cb
cmpb $0x78, 0x10(%rax,%rcx)
jne 0x357f
movq (%r14), %rax
movl (%rax), %ecx
decl %ecx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x35b7
leaq (%rax,%rbp), %rsi
addq $0x10, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8b94
leaq 0x1(%rbp), %r15
movq (%r14), %rax
cmpq %r15, (%rax)
jbe 0x35cb
cmpb $0x3b, 0x11(%rax,%rbp)
movq %r15, %rbp
jne 0x34f4
jmp 0x3592
movq 0x40(%r13), %rsi
movl 0x48(%r13), %edx
jmp 0x3587
movq 0x10(%r13), %rsi
movl 0x18(%r13), %edx
jmp 0x3587
movq 0x30(%r13), %rsi
movl 0x38(%r13), %edx
jmp 0x3587
cmpb $0x1f, %dil
ja 0x35a6
movl $0x20, %esi
movq %r12, %rdi
leaq 0x6a99(%rip), %rdx      # 0xa004
xorl %eax, %eax
callq 0x3240
movq %r12, %rdi
callq 0x30a0
movslq %eax, %rdx
jmp 0x35af
movq (%r13), %rsi
movl 0x8(%r13), %edx
movq %rbx, %rdi
callq 0x8b94
incl %r15d
movq (%r14), %rax
movq (%rax), %rdx
movq %rdx, %rsi
cmpl %edx, %r15d
jl 0x3464
jmp 0x35bc
movb %dil, (%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x358a
movq %rbp, %r15
jmp 0x3592
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f5f(%rip), %rdi      # 0xa531
leaq 0x6f69(%rip), %rsi      # 0xa542
leaq 0x6f6e(%rip), %rcx      # 0xa54e
movl $0x9c, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x368e
movq (%rdi), %rax
movq 0x48(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0x367c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3800
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x36df
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x36c6
jmp 0x3751
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3751
xorl %r15d, %r15d
movq %r14, %r12
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x370e
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x36f3
jmp 0x371b
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 0x373b
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x3721
jmp 0x3748
movq (%r13), %rax
movq %r13, %rdi
callq *0x20(%rax)
movq %rax, %r12
cmpq %r12, %r15
jne 0x381f
cmpl $0x0, 0x20(%r14)
je 0x3784
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 0x37f3
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 0x37ac
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3793
jmp 0x37f3
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x37f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x37ce
movq 0x18(%rbx), %rbx
jmp 0x37ba
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 0x77f6
jmp 0x37f3
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6806(%rip), %rdi      # 0xa00d
leaq 0x6829(%rip), %rsi      # 0xa037
leaq 0x682e(%rip), %rcx      # 0xa043
movl $0xbc, %edx
callq 0x30e0
leaq 0x684d(%rip), %rdi      # 0xa073
leaq 0x680a(%rip), %rsi      # 0xa037
leaq 0x680f(%rip), %rcx      # 0xa043
movl $0xbd, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x386e
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x38c9
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x369c
movq %rbx, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x388a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3871
jmp 0x38c9
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x38c9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x38ac
movq 0x18(%rbx), %rbx
jmp 0x3898
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 0x77f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38ea
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x18(%rsi)
je 0x38f6
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x392f
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x38ea
movq %rax, %r14
movq %rbx, 0x18(%rax)
movq %r15, 0x48(%rax)
movq 0x40(%r15), %rax
movq %rax, 0x40(%r14)
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x3970
addq $0x48, %rax
jmp 0x397d
xorl %r14d, %r14d
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x394e
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3935
jmp 0x38ed
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x38ea
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3989
movq 0x18(%rbx), %rbx
jmp 0x395c
cmpq %r15, 0x28(%rbx)
jne 0x39ae
addq $0x28, %rbx
movq %rbx, %rax
movq %r14, (%rax)
movq %r14, 0x40(%r15)
jmp 0x38ed
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 0x77f6
jmp 0x38ed
leaq 0x6705(%rip), %rdi      # 0xa0ba
leaq 0x667b(%rip), %rsi      # 0xa037
leaq 0x6710(%rip), %rcx      # 0xa0d3
movl $0xff, %edx
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39e4
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x18(%rsi)
je 0x39f0
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x3a29
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x39e4
movq %rax, %r14
movq %rbx, 0x18(%rax)
movq %r15, 0x40(%rax)
movq 0x48(%r15), %rax
movq %rax, 0x48(%r14)
movq 0x48(%r15), %rax
testq %rax, %rax
je 0x3a6a
addq $0x40, %rax
jmp 0x3a77
xorl %r14d, %r14d
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3a48
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3a2f
jmp 0x39e7
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x39e4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3a83
movq 0x18(%rbx), %rbx
jmp 0x3a56
cmpq %r15, 0x30(%rbx)
jne 0x3aa8
addq $0x30, %rbx
movq %rbx, %rax
movq %r14, (%rax)
movq %r14, 0x48(%r15)
jmp 0x39e7
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 0x77f6
jmp 0x39e7
leaq 0x666c(%rip), %rdi      # 0xa11b
leaq 0x6581(%rip), %rsi      # 0xa037
leaq 0x6675(%rip), %rcx      # 0xa132
movl $0x120, %edx            # imm = 0x120
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ade
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x18(%rsi)
je 0x3aea
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x3b17
xorl %r15d, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3b79
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x3afe
jmp 0x3b85
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x3ade
movq %rax, %r14
movq 0x48(%r15), %rax
movq %rax, 0x48(%r14)
movq 0x40(%r15), %rax
movq %rax, 0x40(%r14)
movq 0x48(%r15), %rax
leaq 0x30(%rbx), %rcx
leaq 0x40(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r14, (%rdx)
movq 0x40(%r15), %rax
leaq 0x48(%rax), %rcx
leaq 0x28(%rbx), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %r14, (%rcx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, 0x18(%r14)
jmp 0x3ae1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %r15
testq %r15, %r15
je 0x3ade
xorl %r14d, %r14d
movq %r15, %rdi
movl $0xf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x77f6
jmp 0x3ae1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bf2
cmpq %rdi, 0x18(%rbx)
jne 0x3bfa
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)
movq 0x40(%rbx), %rax
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 0x6578(%rip), %rdi      # 0xa179
leaq 0x642f(%rip), %rsi      # 0xa037
leaq 0x656c(%rip), %rcx      # 0xa17b
movl $0x157, %edx            # imm = 0x157
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChild(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 0x3c47
movq %rsi, %r14
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3c49
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
jne 0x3c2a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c81
movq %rsi, %r14
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3c83
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x3c64
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ca2
cmpq %rdi, 0x18(%rsi)
jne 0x3caa
addq $0x48, %rsi
movq %rsi, %rdi
jmp 0x3ca6
addq $0x28, %rdi
movq (%rdi), %rax
retq
pushq %rax
leaq 0x64f2(%rip), %rdi      # 0xa1a4
leaq 0x637e(%rip), %rsi      # 0xa037
leaq 0x64fd(%rip), %rcx      # 0xa1bd
movl $0x189, %edx            # imm = 0x189
callq 0x30e0