LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: add_magic(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&)
void add_magic(uint32_t tag, const std::string& data,
               std::string& index, std::string& store, size_t& nentries) {

    add_uint32(tag, index);
    add_uint32(rpm::index_t::entry_t::TYPE_BIN, index);
    add_uint32(store.size(), index);
    add_uint32(data.size(), index);

    store += data;

    ++nentries;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdx, %rsi
callq 0xfe16
pushq $0x7
popq %rdi
movq %r15, %rsi
callq 0xfe16
movl 0x8(%r14), %edi
movq %r15, %rsi
callq 0xfe16
movl 0x8(%r12), %edi
movq %r15, %rsi
callq 0xfe16
movq %r14, %rdi
movq %r12, %rsi
callq 0x34c0
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: compress_file(mfile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void compress_file(mfile& in, const std::string& out) {

    gzFile gf = ::gzopen(out.c_str(), "wbx");

    if (gf == NULL) {
        throw std::runtime_error("Could not open for writing: " + out);
    }

    size_t n = ::gzwrite(gf, in.addr, in.size);

    if (n == 0) {
        throw std::runtime_error("Could not write to compressed file: " + out);
    }

    if (::gzclose(gf) != Z_OK) {
        throw std::runtime_error("Error in closing compressed file.");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
leaq 0x807d(%rip), %rsi      # 0x18ea6
callq 0x3210
testq %rax, %rax
je 0x10e64
movq %rax, %rbx
movq (%r15), %rsi
movl 0x10(%r15), %edx
movq %rax, %rdi
callq 0x3520
testl %eax, %eax
je 0x10ead
movq %rbx, %rdi
callq 0x3500
testl %eax, %eax
jne 0x10ef4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x8034(%rip), %rsi      # 0x18eaa
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12bf8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31b0
xorl %ebp, %ebp
movq 0xd14c(%rip), %rsi      # 0x1dfe8
movq 0xd13d(%rip), %rdx      # 0x1dfe0
movq %rbx, %rdi
callq 0x3350
jmp 0x10ef4
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x8008(%rip), %rsi      # 0x18ec7
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12bf8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31b0
xorl %ebp, %ebp
movq 0xd103(%rip), %rsi      # 0x1dfe8
movq 0xd0f4(%rip), %rdx      # 0x1dfe0
movq %rbx, %rdi
callq 0x3350
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x7fe6(%rip), %rsi      # 0x18eec
movq %rax, %rdi
callq 0x3180
movq 0xd0d3(%rip), %rsi      # 0x1dfe8
movq 0xd0c4(%rip), %rdx      # 0x1dfe0
movq %rbx, %rdi
callq 0x3350
jmp 0x10f3e
jmp 0x10f2a
jmp 0x10f3e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x33a0
testb %bpl, %bpl
jne 0x10f41
jmp 0x10f49
movq %rax, %r14
movq %rbx, %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: print_digest[abi:cxx11](unsigned char const*, unsigned long)
std::string print_digest(const unsigned char* digest, size_t len) {

    std::string ret;

    for (size_t i = 0; i < len; ++i) {
        static unsigned char print[16] = {'0', '1', '2', '3', '4', '5', '6', '7', 
                                          '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

        unsigned char c = digest[i];
        ret += print[(c >> 4) & 0xF];
        ret += print[c & 0xF];
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq 0x82a1(%rip), %r13      # 0x19220
cmpq %r12, %r14
je 0x10fb1
movzbl (%r15,%r12), %ebp
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x3660
andl $0xf, %ebp
movsbl (%rbp,%r13), %esi
movq %rbx, %rdi
callq 0x3660
incq %r12
jmp 0x10f7f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x33a0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: make_rpm(rpmprops_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
mfile make_rpm(const rpmprops_t& props, const std::string& payload_file, std::string& header) {

    mfile payload(payload_file);

    std::string index2 = make_index2(props);
    mfile ret = make_index1(index2, payload, payload_file + ".gz", header);
    std::string lead = make_lead(
        props.name,
        htons((uint16_t)(props.arch == "src")) /* 1 for source, 0 for binary */
    );

    header = lead + header + index2;
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x12c6e
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0xff07
leaq 0x7c4b(%rip), %rdx      # 0x18f47
movq %rsp, %rdi
movq %r12, %rsi
callq 0x12e5d
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %r8
callq 0x10fd6
movq %rsp, %rdi
callq 0x33a0
leaq 0x168(%r15), %rdi
leaq 0x7b6d(%rip), %rsi      # 0x18ea2
callq 0x126ab
movzbl %al, %edx
shll $0x8, %edx
movq %rsp, %rdi
movq %r15, %rsi
callq 0xfd84
leaq 0x58(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x12eb4
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x12e95
leaq 0x78(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq %r15, %rdi
callq 0x33a0
leaq 0x58(%rsp), %rdi
callq 0x33a0
movq %rsp, %rdi
callq 0x33a0
leaq 0x38(%rsp), %rdi
callq 0x33a0
leaq 0x20(%rsp), %rdi
callq 0x12e30
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x33a0
jmp 0x113d1
movq %rax, %r14
movq %rsp, %rdi
callq 0x33a0
jmp 0x113de
movq %rax, %r14
movq %rbx, %rdi
callq 0x12e30
jmp 0x113f8
movq %rax, %r14
movq %rsp, %rdi
callq 0x33a0
jmp 0x113f8
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x33a0
leaq 0x20(%rsp), %rdi
callq 0x12e30
movq %r14, %rdi
callq 0x3360
movq %rax, %r14
jmp 0x11402
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: uid_to_uname[abi:cxx11](unsigned int)
std::string uid_to_uname(uid_t uid) {

    struct passwd unam;
    char buf[1024];

    struct passwd* res;
    ::getpwuid_r(uid, &unam, buf, 1024, &res);

    std::string uname;

    if (res == NULL) {
        return "(unknown)";
    } else {
        return res->pw_name;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x468, %rsp            # imm = 0x468
movl %esi, %eax
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x400, %ecx            # imm = 0x400
movl %eax, %edi
movq %r14, %r8
callq 0x3400
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r14), %rax
testq %rax, %rax
je 0x11471
movq (%rax), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3570
jmp 0x11485
leaq 0x7ad3(%rip), %rsi      # 0x18f4b
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3570
leaq 0x10(%rsp), %rdi
callq 0x33a0
movq %rbx, %rax
addq $0x468, %rsp            # imm = 0x468
popq %rbx
popq %r14
retq
jmp 0x1149f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x33a0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: gid_to_gname[abi:cxx11](unsigned int)
std::string gid_to_gname(gid_t gid) {

    struct group gnam;
    char buf[1024];

    struct group* res;
    ::getgrgid_r(gid, &gnam, buf, 1024, &res);

    if (res == NULL) {
        return "(unknown)";
    } else {
        return res->gr_name;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movl %esi, %eax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x400, %ecx            # imm = 0x400
movl %eax, %edi
movq %r14, %r8
callq 0x3490
movq (%r14), %rax
testq %rax, %rax
je 0x114ee
movq (%rax), %rsi
jmp 0x114f5
leaq 0x7a56(%rip), %rsi      # 0x18f4b
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3570
movq %rbx, %rax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/./rpmstruct.h
// Function: rpm::lead_t::lead_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
lead_t(const std::string& _name = "") {

        magic[0] = 0xed;
        magic[1] = 0xab;
        magic[2] = 0xee;
        magic[3] = 0xdb;
        major = 3;
        minor = 0;
        type = 0;
        archnum = 256;          // A big-endian 1.
        osnum = 256;            // A big-endian 1.
        signature_type = 1280;  // A big-endian 5. 

        ::strncpy(name, _name.c_str(), 65);
        name[65] = '\0';
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xdbeeabed, (%rdi)     # imm = 0xDBEEABED
movw $0x3, 0x4(%rdi)
movl $0x1000000, 0x6(%rdi)   # imm = 0x1000000
movl $0x5000100, 0x4c(%rdi)  # imm = 0x5000100
addq $0xa, %rdi
movq (%rsi), %rsi
pushq $0x41
popq %rdx
callq 0x3100
movb $0x0, 0x4b(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void add(uint32_t tag, const std::string& txt, bool i18) {

        add_uint32(tag, index);
        add_uint32((i18 ? rpm::index_t::entry_t::TYPE_I18STRING : rpm::index_t::entry_t::TYPE_STRING), index);
        add_uint32(store.size(), index);
        add_uint32(1, index);
        store += txt;
        store += '\0';

        ++nentries;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xfe16
leal (%r14,%r14,2), %edi
addl $0x6, %edi
movq %rbx, %rsi
callq 0xfe16
leaq 0x20(%rbx), %r14
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xfe16
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0xfe16
movq %r14, %rdi
movq %r15, %rsi
callq 0x34c0
movq %r14, %rdi
xorl %esi, %esi
callq 0x3660
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, unsigned int)
void add(uint32_t tag, uint32_t data) {

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_INT32, index);

        size_t n = (4 - (store.size() % 4)) % 4;

        while (n > 0) {
            store += '\0';
            --n;
        }

        add_uint32(store.size(), index);
        add_uint32(1, index);
        add_uint32(data, store);

        ++nentries;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xfe16
pushq $0x4
popq %rdi
movq %rbx, %rsi
callq 0xfe16
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
subl 0x28(%rbx), %r15d
andl $0x3, %r15d
subq $0x1, %r15
jb 0x1267c
movq %r14, %rdi
xorl %esi, %esi
callq 0x3660
jmp 0x1266a
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xfe16
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0xfe16
movl %ebp, %edi
movq %r14, %rsi
callq 0xfe16
incq 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, unsigned long)
void add(uint32_t tag, uint64_t data) {

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_INT64, index);

        size_t n = (8 - (store.size() % 8)) % 8;

        while (n > 0) {
            store += '\0';
            --n;
        }

        add_uint32(store.size(), index);
        add_uint32(1, index);
        add_uint64(data, store);

        ++nentries;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xfe16
pushq $0x5
popq %rdi
movq %rbx, %rsi
callq 0xfe16
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
subl 0x28(%rbx), %r15d
andl $0x7, %r15d
subq $0x1, %r15
jb 0x129d4
movq %r14, %rdi
xorl %esi, %esi
callq 0x3660
jmp 0x129c2
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xfe16
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0xfe16
movq %r14, %rsi
callq 0xfe63
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::str[abi:cxx11](unsigned int)
std::string str(uint32_t tag) {
        // Add a pointless 'magic' field, which goes into the end of the store but as the first index entry.

        std::string magic;
        std::string magic_payload;

        int32_t magic_offset = -((nentries + 1) * rpm::index_t::entry_t::SIZE);

        add_uint32(tag, magic_payload);
        add_uint32(rpm::index_t::entry_t::TYPE_BIN, magic_payload);
        add_uint32((uint32_t)magic_offset, magic_payload);
        add_uint32(rpm::index_t::entry_t::SIZE, magic_payload);

        add_magic(tag, magic_payload, magic, store, nentries);

        // Add header with the number of fields.

        std::string iheader;
        iheader += '\x8e';
        iheader += '\xad';
        iheader += '\xe8';
        iheader += '\x01';
        add_uint32(0, iheader);
        add_uint32(nentries, iheader);
        add_uint32(store.size(), iheader);

        return iheader + magic + index + store;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
movl 0x40(%rsi), %r15d
leaq 0x20(%rsp), %rsi
movl %ebp, %edi
callq 0xfe16
pushq $0x7
popq %rdi
leaq 0x20(%rsp), %rsi
callq 0xfe16
notl %r15d
shll $0x4, %r15d
leaq 0x20(%rsp), %rsi
movl %r15d, %edi
callq 0xfe16
pushq $0x10
popq %rdi
leaq 0x20(%rsp), %rsi
callq 0xfe16
leaq 0x40(%r14), %r12
leaq 0x20(%r14), %r15
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl %ebp, %edi
movq %r15, %rcx
movq %r12, %r8
callq 0xfead
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
pushq $-0x72
popq %rsi
callq 0x3660
movq %rsp, %rdi
pushq $-0x53
popq %rsi
callq 0x3660
movq %rsp, %rdi
pushq $-0x18
popq %rsi
callq 0x3660
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x3660
movq %rsp, %rsi
xorl %edi, %edi
callq 0xfe16
movl (%r12), %edi
movq %rsp, %rsi
callq 0xfe16
movl 0x28(%r14), %edi
movq %rsp, %rsi
callq 0xfe16
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
callq 0x12eb4
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %r14, %rdx
callq 0x12e95
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12e95
leaq 0x80(%rsp), %rdi
callq 0x33a0
leaq 0x60(%rsp), %rdi
callq 0x33a0
movq %rsp, %rdi
callq 0x33a0
leaq 0x20(%rsp), %rdi
callq 0x33a0
leaq 0x40(%rsp), %rdi
callq 0x33a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x33a0
jmp 0x12b86
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x33a0
jmp 0x12b9c
jmp 0x12b99
movq %rax, %rbx
jmp 0x12ba4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x33a0
leaq 0x20(%rsp), %rdi
callq 0x33a0
leaq 0x40(%rsp), %rdi
callq 0x33a0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]makerpm/./mfile.h
// Function: mfile::mfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mfile(const std::string& f) {

        fd = ::open(f.c_str(), O_RDONLY|O_LARGEFILE);
        
        if (fd < 0) {
            throw std::runtime_error("Could not open: " + f);
        }

        struct stat st;

        if (::fstat(fd, &st) < 0) {
            throw std::runtime_error("Could not stat: " + f);
        }

        size = st.st_size;

        addr = ::mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3270
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0x12cce
leaq 0x20(%rsp), %rsi
movl %eax, %edi
callq 0x34e0
testl %eax, %eax
js 0x12d17
movq 0x50(%rsp), %rsi
movq %rsi, 0x10(%rbx)
movl 0x8(%rbx), %r8d
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
xorl %r9d, %r9d
callq 0x3530
movq %rax, (%rbx)
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x6485(%rip), %rsi      # 0x19165
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x12bf8
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x31b0
xorl %ebp, %ebp
movq 0xb2e2(%rip), %rsi      # 0x1dfe8
movq 0xb2d3(%rip), %rdx      # 0x1dfe0
movq %rbx, %rdi
callq 0x3350
jmp 0x12d5a
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x646b(%rip), %rsi      # 0x19194
movq %rsp, %rdi
movq %r14, %rdx
callq 0x12bf8
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x31b0
xorl %ebp, %ebp
movq 0xb29d(%rip), %rsi      # 0x1dfe8
movq 0xb28e(%rip), %rdx      # 0x1dfe0
movq %rbx, %rdi
callq 0x3350
movq %rax, %r14
movq %rsp, %rdi
jmp 0x12d6c
jmp 0x12d78
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x33a0
testb %bpl, %bpl
jne 0x12d7b
jmp 0x12d83
movq %rax, %r14
movq %rbx, %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/ChFlux_Rct_Evt.cpp
// Function: nw::ChFlux_Rct_Evt::update(double)
double ChFlux_Rct_Evt::update(double last_tau){

	double minTau = INFINITY;
	double actTau;

//	run through the tv vector
	for (long i = 0; i < (long) tv_vec.size(); i++) {
//		check for voxel that have been affected by last executed event
		if (tv_vec.at(i).v->get_dirty_flag()) {
			actTau = calc_tau(i);
//			find smallest tau value (->next voxel) for this event
			if (actTau < minTau) {
				minTau = actTau;
				nextVoxel = i;
			}
//		this voxel has not been affected by last event
		} else {
//			adjust tau value to global times scale
			tv_vec.at(i).t -= last_tau;
//			find smallest tau value (->next voxel) for this event
			if (tv_vec[i].t < minTau) {
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}
	this->dirty_flag = false;

	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movsd 0x196aa(%rip), %xmm0    # 0x1e008
movsd %xmm0, 0x8(%rsp)
pushq $0x8
popq %r12
xorl %r15d, %r15d
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
sarq $0x4, %rax
cmpq %rax, %r15
jge 0x49e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x4aa4
movq (%rax), %rax
cmpb $0x1, 0x20(%rax)
jne 0x499d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49fa
jmp 0x49c1
movq %r14, %rdi
movq %r15, %rsi
callq 0x4aa4
movsd 0x8(%rax), %xmm0
subsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq (%r14), %rax
movsd (%rax,%r12), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x49d7
movq %r15, 0x70(%rbx)
movsd %xmm0, 0x8(%rsp)
incq %r15
addq $0x10, %r12
jmp 0x496b
movb $0x0, 0x80(%rbx)
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::init()
void Diffusion_Evt::init(){

//	calculate the correct diffusion probability constant according to the voxel volume
	this->c = (k*1e-3)/pow(tv_vec[0].v->get_box_length()*1e6,2);

//	build state change vector
	build_sc_vec();

//	update the first time
	update(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm0
mulsd 0x192c7(%rip), %xmm0    # 0x1e0a8
movq 0x50(%rdi), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm1
mulsd 0x192bb(%rip), %xmm1    # 0x1e0b0
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rdi)
callq 0x4e18
movq (%rbx), %rax
movq 0x10(%rax), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::build_sc_vec()
void Diffusion_Evt::build_sc_vec(){
//	build sc_vec
	sc_vec.assign(tv_vec[0].v->get_state_vec()->size(),0);
	inv_sc_vec.assign(tv_vec[0].v->get_state_vec()->size(),0);
	sc_vec[diff_spec_id] = -1;
	inv_sc_vec[diff_spec_id] = 1;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
movq %rsp, %r14
andq $0x0, (%r14)
movq %r14, %rdx
callq 0x534e
leaq 0xa0(%rbx), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
andq $0x0, (%r14)
movq %rsp, %rdx
callq 0x534e
movq 0x38(%rbx), %rax
movq 0xb8(%rbx), %rcx
orq $-0x1, (%rax,%rcx,8)
movq 0xa0(%rbx), %rax
movq 0xb8(%rbx), %rcx
movq $0x1, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::execute()
void Diffusion_Evt::execute(){
//	update diffusion origin voxel with the inverse state change vector
	tv_vec[nextVoxel].v->update_state(sc_vec);

//	choose diffusion partner
	double r = rg->get_Uni_Rnd();
	double d; // temp
	for (size_t i = 0; i < tv_vec[nextVoxel].v->get_diff_vec()->size(); ++i){
		d = (double)(i+1)/tv_vec[nextVoxel].v->get_diff_vec()->size();
		if(r-d < 0){
			tv_vec[nextVoxel].v->get_diff_vec()->at(i)->update_state(inv_sc_vec);
			break;
		}
	}

//	set dirty flag to indicate that dependent events have to be updated properly
	for(size_t i = 0; i < dep_list.size(); i++){
		dep_list[i]->set_flag(true);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r15
leaq 0x38(%rdi), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x525c
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
callq 0x4b54
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x50(%rbx), %rax
movq 0x70(%rbx), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rcx
movq 0x48(%rcx), %rax
subq 0x40(%rcx), %rax
sarq $0x3, %rax
movq %rax, %xmm2
punpckldq 0x191b1(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x191b9(%rip), %xmm2    # 0x1e0d0
leaq 0x40(%rcx), %rdi
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
negq %rax
pushq $0x1
popq %rsi
movq 0x1918b(%rip), %xmm2    # 0x1e0c0
movapd 0x19193(%rip), %xmm3    # 0x1e0d0
leaq (%rax,%rsi), %rcx
cmpq $0x1, %rcx
je 0x4f9f
movq %rsi, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
divsd %xmm1, %xmm5
incq %rsi
ucomisd %xmm0, %xmm5
jbe 0x4f3d
addq $-0x2, %rsi
callq 0x52aa
movq (%rax), %r15
leaq 0xa0(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x525c
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rsp, %rdi
callq 0x4b54
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4fcb
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
jmp 0x4fb6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4fd7
movq %rax, %rbx
movq %r14, %rdi
callq 0x4b54
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::update(double)
double Diffusion_Evt::update(double last_tau){

	double minTau = INFINITY, actTau;

//	check if this event depends on the last executed event
	if (this->dirty_flag) {
//		run through the tv vector
		for (size_t i = 0; i < tv_vec.size(); ++i) {
//			check for voxel that have been affected by last executed event
			if (tv_vec[i].v->get_dirty_flag()) {
				actTau = calc_tau(i);
//				find smallest tau value (->next voxel) for this event
				if (actTau < minTau) {
					minTau = actTau;
					nextVoxel = i;
				}
//			voxel has not been affected by last event
			} else {
//				adjust tau value to global times scale
				tv_vec[i].t -= last_tau;
//				find smallest tau value (->next voxel) for this event
				if (tv_vec[i].t < minTau) {
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
			}
		}
//  event has not been affected by last event
	} else {
//		adjust tau values to global times scale
		for (size_t i = 0; i < tv_vec.size(); ++i) {
			tv_vec[i].t -= last_tau;
			if (tv_vec[i].t < minTau) {
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}

	this->dirty_flag = false;
	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
cmpb $0x0, 0x80(%rdi)
je 0x507f
movsd 0x18ffd(%rip), %xmm2    # 0x1e008
pushq $0x8
popq %r15
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r14
jae 0x50c4
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x5058
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x50da
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
jmp 0x5068
movsd (%rax,%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm2
jbe 0x5076
movq %r14, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %r14
addq $0x10, %r15
jmp 0x5017
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x8, %rax
movsd 0x18f6e(%rip), %xmm2    # 0x1e008
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x50c4
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
ucomisd %xmm0, %xmm2
jbe 0x50bb
movq %rdx, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %rdx
addq $0x10, %rax
jmp 0x509c
movb $0x0, 0x80(%rbx)
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::calc_tau(long)
double Diffusion_Evt::calc_tau(long vid){
//	adapt the c value to the number of diffusion sites!
	double c_adapted =  c * tv_vec.at(vid).v->get_diff_vec()->size();
//	calculate tau
	tv_vec[vid].t = -log(rg->get_Uni_Rnd()) / (tv_vec[vid].v->get_state_vec()->
			at(diff_spec_id)->get_n_molecules() * c_adapted);

	return tv_vec[vid].t;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x78(%rdi), %xmm0
movsd %xmm0, (%rsp)
addq $0x50, %rdi
callq 0x4aa4
movq (%rax), %rax
movq 0x48(%rax), %rcx
subq 0x40(%rax), %rcx
sarq $0x3, %rcx
movq %rcx, %xmm0
punpckldq 0x18faa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18fb2(%rip), %xmm0    # 0x1e0d0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
movq 0x68(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x41e0
xorpd 0x18ec6(%rip), %xmm0    # 0x1e010
movapd %xmm0, 0x10(%rsp)
shlq $0x4, %rbx
movq 0x50(%r14), %rax
movq 0xb8(%r14), %rsi
movq (%rax,%rbx), %rdi
addq $0x28, %rdi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cvtsi2sd %rax, %xmm1
mulsd (%rsp), %xmm1
movapd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x50(%r14), %rax
movsd %xmm0, 0x8(%rax,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::get_a()
double Diffusion_Evt::get_a(){
	double a_ges = 0;
	for(long i = 0; i < (long) tv_vec.size(); i++){
		a_ges += c*tv_vec[i].v->get_state_vec()->at(diff_spec_id)->get_n_molecules() *
				tv_vec[i].v->get_diff_vec()->size();
	}
	return a_ges;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r15
jge 0x5252
movsd 0x78(%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
movq (%rax,%r14), %rdi
addq $0x28, %rdi
movq 0xb8(%rbx), %rsi
movapd %xmm0, 0x10(%rsp)
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cvtsi2sd %rax, %xmm0
movq 0x50(%rbx), %rax
movq (%rax,%r14), %rcx
movq 0x48(%rcx), %rdx
subq 0x40(%rcx), %rdx
mulsd 0x8(%rsp), %xmm0
sarq $0x3, %rdx
movq %rdx, %xmm1
punpckldq 0x18e9c(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x18ea4(%rip), %xmm1    # 0x1e0d0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movapd 0x10(%rsp), %xmm0
addsd %xmm2, %xmm0
incq %r15
addq $0x10, %r14
jmp 0x51b6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::init()
void Reaction_Evt::init(){

//	build educt vector
	build_educt_vector();

//	calculate the correct probability rate constant depending on the reaction order.
	if (educt_vec.size() == 1){
		this->c = k;
	}else if(educt_vec.size() == 2){
		this->c = k/(tv_vec[0].v->get_volume()*N_AVO*1e-6);
	}

//	update the Reaction Event the first time
	update(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5502
movq 0xa8(%rbx), %rax
subq 0xa0(%rbx), %rax
sarq $0x3, %rax
cmpq $0x2, %rax
je 0x54c6
cmpq $0x1, %rax
jne 0x54f0
movsd 0x30(%rbx), %xmm0
jmp 0x54eb
movq 0x50(%rbx), %rax
movq (%rax), %rax
movsd 0x18(%rax), %xmm1
mulsd 0x18c4e(%rip), %xmm1    # 0x1e128
movsd 0x30(%rbx), %xmm0
mulsd 0x18c49(%rip), %xmm1    # 0x1e130
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rbx)
movq (%rbx), %rax
movq 0x10(%rax), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::execute()
void Reaction_Evt::execute(){
	try{
//		execute event by using the state change vector
		tv_vec[nextVoxel].v->update_state(sc_vec);

//		set dirty flag to indicate that dependent events have to be updated
		this->dirty_flag = true;
		for(size_t i = 0; i < dep_list.size(); i++){
			dep_list[i]->set_flag(true);
		}
	}
	catch(exception& e){
		cout << "Reaction_Evt::execute(): " << e.what();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
leaq 0x38(%rdi), %rsi
movq %rsp, %rdi
callq 0x525c
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq %rsp, %rdi
callq 0x4b54
movb $0x1, 0x80(%rbx)
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x5619
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
jmp 0x55ae
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b54
jmp 0x55d9
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x5629
movq %rbx, %rdi
callq 0x40e0
movq %rax, %rbx
movq 0x299d7(%rip), %rdi     # 0x2efc8
leaq 0x18b40(%rip), %rsi     # 0x1e138
callq 0x4240
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4240
callq 0x4480
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
callq 0x4480
movq %rbx, %rdi
callq 0x44f0
movq %rax, %rdi
callq 0x4b49
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::update(double)
double Reaction_Evt::update(double last_tau){

	double minTau = INFINITY;

//	check if this event depends on the last executed event
	if(this->dirty_flag){
//		run through the tv vector
		for (size_t i = 0; i < tv_vec.size(); ++i){
//			check for voxel that have been affected by last executed event
			if (tv_vec[i].v->get_dirty_flag()){
//				find smallest tau value (->next voxel) for this event
				if(calc_tau(i) < minTau){
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
//			voxel has not been affected by last event
			} else {
//				adjust tau value to global times scale
				tv_vec[i].t -= last_tau;
//				find smallest tau value (->next voxel) for this event
				if(tv_vec[i].t < minTau){
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
			}
		}
//  event has not been affected by last event
	} else  {
//		adjust tau values to global times scale
		for (size_t i = 0; i < tv_vec.size(); ++i) {
			tv_vec[i].t -= last_tau;
			if(tv_vec[i].t < minTau){
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}

	this->dirty_flag = false;
	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
cmpb $0x0, 0x80(%rdi)
je 0x56e3
movsd 0x189a9(%rip), %xmm2    # 0x1e008
pushq $0x8
popq %r15
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r14
jae 0x5728
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x56bc
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x573e
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm2
jbe 0x56da
movq 0x50(%rbx), %rax
movsd (%rax,%r15), %xmm0
jmp 0x56d2
movsd (%rax,%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm2
jbe 0x56da
movq %r14, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %r14
addq $0x10, %r15
jmp 0x566b
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x8, %rax
movsd 0x1890a(%rip), %xmm2    # 0x1e008
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x5728
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
ucomisd %xmm0, %xmm2
jbe 0x571f
movq %rdx, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %rdx
addq $0x10, %rax
jmp 0x5700
movb $0x0, 0x80(%rbx)
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::calc_tau(long)
double Reaction_Evt::calc_tau(long vid){

// 	make sure the educt vector is valid -> only first -and second order reactions are allowed
	if(educt_vec.size() > 0 && educt_vec.size() <= 2){
		double a = c;
		for (size_t i = 0; i < educt_vec.size(); ++i){
			a *= tv_vec[vid].v->get_state_vec()->at(educt_vec[i])->get_n_molecules();
		}
		tv_vec[vid].t = -log(rg->get_Uni_Rnd()) / a;

		return tv_vec[vid].t;
	} else {
		cout << "ERROR: Only first and second order reactions are allowed! "
				"Check sc_vec of:" << this->name <<endl;
		exit(0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xa0(%rdi), %rax
movq 0xa8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x5806
cmpq $0x10, %rdx
ja 0x5806
movq %rsi, %r14
movsd 0x78(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
shlq $0x4, %r14
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jae 0x57d5
movq 0x50(%rbx), %rcx
movq (%rcx,%r14), %rdi
addq $0x28, %rdi
movq (%rax,%r15,8), %rsi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incq %r15
movq 0xa0(%rbx), %rax
movq 0xa8(%rbx), %rcx
jmp 0x5783
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x41e0
xorpd 0x18825(%rip), %xmm0    # 0x1e010
divsd 0x8(%rsp), %xmm0
movq 0x50(%rbx), %rax
movsd %xmm0, 0x8(%rax,%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x297bb(%rip), %rdi     # 0x2efc8
leaq 0x1893e(%rip), %rsi     # 0x1e152
callq 0x4240
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4210
movq %rax, %rdi
callq 0x4100
xorl %edi, %edi
callq 0x42d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::get_a()
double Reaction_Evt::get_a(){
	double a_ges = 0;
	for(size_t i = 0; i < tv_vec.size(); ++i){
		double a = c;
		for (size_t j = 0; j < educt_vec.size(); ++j){
			a *= tv_vec[i].v->get_state_vec()->at(educt_vec[j])->get_n_molecules();
		}
		a_ges += a;
	}
	return a_ges;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
sarq $0x4, %rax
cmpq %rax, %r14
jae 0x58dd
movsd 0x78(%rbx), %xmm1
movq %r14, %r15
shlq $0x4, %r15
xorl %r12d, %r12d
movq 0xa0(%rbx), %rax
movq 0xa8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x58c5
movq 0x50(%rbx), %rcx
movq (%rcx,%r15), %rdi
addq $0x28, %rdi
movq (%rax,%r12,8), %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd 0x10(%rsp), %xmm1
cvtsi2sd %rax, %xmm0
mulsd %xmm0, %xmm1
incq %r12
jmp 0x5873
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r14
jmp 0x5853
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/SubUnitSwitch_Rct_Evt.cpp
// Function: nw::SubUnitSwitch_Rct_Evt::execute()
void SubUnitSwitch_Rct_Evt::execute(){

	try{
//		execute event by using the state change vector
		tv_vec[nextVoxel].v->update_state(sc_vec);

//		set dirty flag to indicate that dependent events have to be updated properly
		for(long i = 0; i < (long)dep_list.size(); i++){
			dep_list[i]->set_flag(true);
		}

//		update the activation states of the subunits of chs
		chs = dynamic_cast<Channel_Spc*>(tv_vec[nextVoxel].v->get_state_vec()->at(ch_spc_id));
		update_Channel_Spc();
	}
	catch(exception& e){
		cout << "SubuintSwitch_Rct_evt::execute(): " << e.what();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
leaq 0x38(%rdi), %rsi
movq %rsp, %rdi
callq 0x525c
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq %rsp, %rdi
callq 0x4b54
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x5a6a
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
jmp 0x5a55
movq 0x50(%rbx), %rax
movq 0x70(%rbx), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
addq $0x28, %rdi
movq 0xc8(%rbx), %rsi
callq 0x4ac6
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5aa9
leaq 0x28e1f(%rip), %rsi     # 0x2e8b8
leaq 0x28e28(%rip), %rdx     # 0x2e8c8
xorl %ecx, %ecx
callq 0x4290
jmp 0x5aab
xorl %eax, %eax
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
callq 0x5b32
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b54
jmp 0x5ad8
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x5b22
movq %rbx, %rdi
callq 0x40e0
movq %rax, %rbx
movq 0x294d8(%rip), %rdi     # 0x2efc8
leaq 0x186dc(%rip), %rsi     # 0x1e1d3
callq 0x4240
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4240
callq 0x4480
jmp 0x5aba
movq %rax, %rbx
callq 0x4480
movq %rbx, %rdi
callq 0x44f0
movq %rax, %rdi
callq 0x4b49
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Events/SubUnitSwitch_Rct_Evt.cpp
// Function: nw::SubUnitSwitch_Rct_Evt::update_Channel_Spc()
void SubUnitSwitch_Rct_Evt::update_Channel_Spc(){

	if (sc_vec.at(act_su_id) > 0){
		long r_chid = (long)(rg->get_Uni_Rnd() * chs->get_n_Activable_Ch());
		chs->activate_Subunit(r_chid);
	}else if(sc_vec.at(act_su_id) < 0){
		long r_chid = (long)(rg->get_Uni_Rnd() * chs->get_n_Inactivable_Ch());
 		chs->inactivate_Subunit(r_chid);
	}else{
		cout << "ERROR: The SubUnitActSwitch_Rct_Evt state change vector doesn't suit the"
				" assigned active_subUnit_Species_ID. Please check your input!" << endl;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq 0xc0(%rdi), %rsi
movq %r14, %rdi
callq 0x4ae8
cmpq $0x0, (%rax)
jle 0x5b84
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0xb8(%rbx), %rdi
movq 0x38(%rdi), %rax
subq 0x60(%rdi), %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb380
movq 0xc0(%rbx), %rsi
movq %r14, %rdi
callq 0x4ae8
cmpq $0x0, (%rax)
js 0x5bbb
movq 0x29428(%rip), %rdi     # 0x2efc8
leaq 0x1864f(%rip), %rsi     # 0x1e1f6
callq 0x4240
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4100
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0xb8(%rbx), %rdi
movq 0x38(%rdi), %rax
subq 0x68(%rdi), %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::get_System()
_System* Standard_Ipt::get_System(){
	read_Sim_Data();
//	create Gillespie_Sys
	s = new Gillespie_Sys(	xgd.xml_output_mode, xgd.xml_max_sim_steps, xgd.xml_max_sim_time,
							xgd.xml_sample_rate,&evc, &vvc,output_dir_path,xgd.xml_output_Spc,
							xgd.xml_output_Vxl);
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
callq 0x60c4
movl $0xf00, %edi            # imm = 0xF00
callq 0x4260
movq %rax, %rbx
cvttsd2si 0x78(%r14), %r15
movq 0x70(%r14), %r12
movsd 0x80(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x88(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4380
leaq 0x98(%r14), %rsi
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x525c
leaq 0xb0(%r14), %rsi
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0x525c
leaq 0x450(%r14), %rcx
leaq 0x468(%r14), %r8
leaq 0x48(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
pushq %rbp
pushq %r13
callq 0xb460
popq %rax
popq %rcx
movq %rbx, 0x8(%r14)
leaq 0x18(%rsp), %rdi
callq 0x4b54
leaq 0x30(%rsp), %rdi
callq 0x4b54
leaq 0x48(%rsp), %rdi
callq 0x4568
movq 0x8(%r14), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4b54
jmp 0x6090
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4b54
jmp 0x609f
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x4568
jmp 0x60ae
movq %rax, %r14
movl $0xf00, %esi            # imm = 0xF00
movq %rbx, %rdi
callq 0x4270
movq %r14, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::build_header[abi:cxx11]()
string Standard_Ipt::build_header(){
	time_t rawtime;
	time ( &rawtime );

	string tmp = 	"STOCHASTIC SIMULATION SOFTWARE \n ------------------"
					"--------------------------------\n developed by Nicolas Wieder and "
					"Frederic von Wegner \n Medical Biophysics Group, Institute of "
					"Physiology and Pathophysiology,\n University of Heidelberg, "
					"69120 Heidelberg, Germany\n----------------------------------"
					"----------------\n\n";
	tmp += ctime (&rawtime);
	return tmp;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4220
leaq 0x17ff2(%rip), %rsi     # 0x1e700
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8e86
movq %r14, %rdi
callq 0x40d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4540
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4568
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::alloc_Species()
void Standard_Ipt::alloc_Species(){
	cout << "alloc Species... ";

	for (long i = 0; i < (long) xgd.xml_spc_list.size(); i++){
		_Species* ts = new Standard_Spc(xgd.xml_spc_list[i]->xml_id,
						xgd.xml_spc_list[i]->xml_name, xgd.xml_spc_list[i]->xml_init_conc);
		svc.push_back(ts);
	}
	for (long i = 0; i < (long) xgd.xml_ch_spc_list.size(); i++){
		_Species* tcs = new Channel_Spc(xgd.xml_ch_spc_list[i]->xml_id,
						xgd.xml_ch_spc_list[i]->xml_name, xgd.xml_ch_spc_list[i]->
						xml_init_conc,
						xgd.xml_ch_spc_list[i]->xml_n_subunits,	xgd.xml_ch_spc_list[i]->
						xml_n_suToOpen);
		svc.push_back(tcs);
	}

	cout << "DONE" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x26f5c(%rip), %rdi     # 0x2efc8
leaq 0x1660d(%rip), %rsi     # 0x1e680
callq 0x4240
leaq 0x480(%rbx), %r14
xorl %r13d, %r13d
leaq 0x28(%rsp), %r12
movq 0x140(%rbx), %r15
movq 0x148(%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jge 0x80f9
pushq $0x50
popq %rdi
callq 0x4260
movq %rax, %rbp
movq (%r15,%r13,8), %rsi
movq (%rsi), %r15
addq $0x8, %rsi
movq %r12, %rdi
callq 0x4380
movq 0x140(%rbx), %rax
movq (%rax,%r13,8), %rax
movsd 0x28(%rax), %xmm0
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x90ca
movq %r12, %rdi
callq 0x4568
movq %rbp, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x9136
incq %r13
jmp 0x8087
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq 0x158(%rbx), %rbp
movq 0x160(%rbx), %rax
subq %rbp, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jge 0x817d
movl $0x90, %edi
callq 0x4260
movq %rax, %r13
movq (%rbp,%r12,8), %rsi
movq (%rsi), %rbp
addq $0x8, %rsi
movq %r15, %rdi
callq 0x4380
movq 0x158(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd 0x28(%rax), %xmm0
movl 0x30(%rax), %ecx
movl 0x38(%rax), %r8d
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x9154
movq %r15, %rdi
callq 0x4568
movq %r13, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x9136
incq %r12
jmp 0x8101
movq 0x26e44(%rip), %rdi     # 0x2efc8
leaq 0x1635e(%rip), %rsi     # 0x1e4e9
callq 0x4240
movq %rax, %rdi
callq 0x4100
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4568
jmp 0x81b9
movq %rax, %rbx
movl $0x90, %esi
movq %r13, %rdi
jmp 0x81db
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4568
jmp 0x81d5
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %rbp, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::clone_svc()
vector<_Species*> Standard_Ipt::clone_svc(){
	vector<_Species*> svcClone;
	svcClone.resize(svc.size());

	for (long i = 0; i < (long) svc.size(); i++)
		svcClone[i] = svc[i]->copy();
	return svcClone;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x488(%rsi), %rsi
subq 0x480(%r14), %rsi
sarq $0x3, %rsi
callq 0x9762
xorl %r15d, %r15d
movq 0x480(%r14), %rax
movq 0x488(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jge 0x8cc8
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x8c98
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8cd3
movq %rax, %r14
movq %rbx, %rdi
callq 0x9c1e
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::build_sc_vector(nw::Standard_Ipt::xml_Rct_Evt* const&)
vector<long> Standard_Ipt::build_sc_vector(xml_Rct_Evt* const& cxe){
	vector<long>* scv  = new vector<long>;
	scv->resize(vvc[cxe->xml_vxl[0]]->get_state_vec()->size());
	long i;

	for (i = 0; i < (long)cxe->xml_educts.size(); i++)
		scv->at(cxe->xml_educts.at(i)) = -1;
	for (i = 0; i < (long)cxe->xml_products.size(); i++)
		scv->at(cxe->xml_products.at(i)) = 1;

	return *scv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x4260
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%r14), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq 0x468(%r12), %rcx
movq (%rcx,%rax,8), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x9730
xorl %r12d, %r12d
movq (%r14), %rdi
movq 0x50(%rdi), %rax
subq 0x48(%rdi), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jge 0x8d6e
addq $0x48, %rdi
movq %r12, %rsi
callq 0x4ae8
movq (%rax), %rsi
movq %r15, %rdi
callq 0x4ae8
orq $-0x1, (%rax)
incq %r12
jmp 0x8d3a
xorl %r12d, %r12d
movq 0x68(%rdi), %rax
subq 0x60(%rdi), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jge 0x8da8
addq $0x60, %rdi
movq %r12, %rsi
callq 0x4ae8
movq (%rax), %rsi
movq %r15, %rdi
callq 0x4ae8
movq $0x1, (%rax)
incq %r12
movq (%r14), %rdi
jmp 0x8d71
movq %rbx, %rdi
movq %r15, %rsi
callq 0x525c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq