LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: baziotis[P]minijava-cpp/./buf.h
// Function: Buf<VMethod>::deep_copy()
Buf<T> deep_copy() {
        Buf<T> copy(cap);
        memcpy(copy.data, data, len * sizeof(T));
        copy.len = len;
        return copy;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rsi
callq 0x17d80
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rdi
movq 0x10(%rax), %rsi
movq 0x8(%rax), %rdx
shlq $0x4, %rdx
callq 0x2100
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: VirtualTable::clear()
void clear() {
        nelems = 0;
        vmethods.clear();
        for (ssize_t i = 0; i < nbuckets; ++i) {
            buckets[i].clear();
        }
        deallocate(MEM::VTABLE);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, (%rdi)
addq $0x1308, %rdi           # imm = 0x1308
callq 0x17360
movq $0x0, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jae 0x15b9c
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
imulq $0x98, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x17330
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x15b6f
movl $0x5, %edi
callq 0x25d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./typecheck.h
// Function: SerializedHashTable<IdType*>::reserve(unsigned long)
inline void reserve(size_t n) {
        if (n == 0) {
          return;
        }
        cap = n;
        len = 0;
        serialized = (T *) allocate(cap * sizeof(T), MEM::TYPECHECK);
        assert(serialized);
        table.reserve(cap);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15d01
jmp 0x15d67
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq 0x28(%rax), %rdi
shlq $0x3, %rdi
movl $0x3, %esi
callq 0x2340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
je 0x15d3b
jmp 0x15d5a
leaq 0x6f48(%rip), %rdi      # 0x1cc8a
leaq 0x6f4c(%rip), %rsi      # 0x1cc95
movl $0x2d, %edx
leaq 0x72d4(%rip), %rcx      # 0x1d029
callq 0x20d0
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rsi
callq 0x178d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./typecheck.h
// Function: SerializedHashTable<IdType*>::insert(char const*, IdType*)
inline bool insert(const char *id, T v) {
        if (len == cap) return false;
        // Insert into HT
        if (table.insert(id, v)) {
            // Insert into serialized data
            serialized[len] = v;
            len = len + 1;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x15dbc
movb $0x0, -0x1(%rbp)
jmp 0x15dfd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17f40
testb $0x1, %al
jne 0x15dd3
jmp 0x15df9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rsi
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x15dfd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/./llvm.h
// Function: lbl_pair_t::construct(char const*)
void construct(const char *lbl) {
        long num = gen_lbl();
        size_t len = strlen(lbl);
        size_t alloc_size = len + 10;
        char *pstart = (char *) allocate(alloc_size, MEM::FUNC);
        char *pend = (char *) allocate(alloc_size, MEM::FUNC);
        sprintf(pstart, "%s", lbl);
        sprintf(pend, "%s_end", lbl);
        start.construct(pstart, num);
        end.construct(pend, num);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x5ab0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x2340
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x2340
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2e6e(%rip), %rsi      # 0x193eb
movb $0x0, %al
callq 0x2040
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x685f(%rip), %rsi      # 0x1cdf2
movb $0x0, %al
callq 0x2040
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x167d0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x167d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/./array.h
// Function: Array<llvalue_t, (MEM)4>::push(llvalue_t)
void push(T v) {
        constexpr size_t size_t_max = std::numeric_limits<size_t>::max();
        assert(len < size_t_max);
        assert(len < cap);
        size_t new_len = len + 1;
        data[len] = v;
        len = new_len;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $-0x1, -0x10(%rbp)
cmpq $-0x1, 0x8(%rax)
jae 0x1665d
jmp 0x1667c
leaq 0x66a3(%rip), %rdi      # 0x1cd07
leaq 0x4378(%rip), %rsi      # 0x1a9e3
movl $0x22, %edx
leaq 0x6c54(%rip), %rcx      # 0x1d2cb
callq 0x20d0
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq (%rcx), %rax
jae 0x1668b
jmp 0x166aa
leaq 0x66d7(%rip), %rdi      # 0x1cd69
leaq 0x434a(%rip), %rsi      # 0x1a9e3
movl $0x23, %edx
leaq 0x6c26(%rip), %rcx      # 0x1d2cb
callq 0x20d0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rsi
shlq $0x5, %rsi
addq %rsi, %rcx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./llvm.h
// Function: llvm_label_t::construct(char const*, long)
void construct(const char *_lbl, long num = -1) {
        assert(_lbl);
        assert(lbl == NULL);
        if (num == -1) {
            num = gen_lbl();
        }

        // Labels are allocated in MEM::FUNC arena.
        // This arena is freed when we finish a method.

        size_t len = strlen(_lbl);
        // Allocate space that will surely be enough.
        size_t alloc_size = len + 20;
        char *p = (char *) allocate(alloc_size, MEM::FUNC);
        // sprintf might be slow.
        sprintf(p, "%s%ld", _lbl, num);
        lbl = (const char *) p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x167f5
jmp 0x16814
leaq 0x6666(%rip), %rdi      # 0x1ce62
leaq 0x6664(%rip), %rsi      # 0x1ce67
movl $0x11, %edx
leaq 0x6661(%rip), %rcx      # 0x1ce70
callq 0x20d0
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x16820
jmp 0x1683f
leaq 0x667a(%rip), %rdi      # 0x1cea1
leaq 0x6639(%rip), %rsi      # 0x1ce67
movl $0x12, %edx
leaq 0x6636(%rip), %rcx      # 0x1ce70
callq 0x20d0
cmpq $-0x1, -0x18(%rbp)
jne 0x1684f
callq 0x5ab0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x2340
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x6620(%rip), %rsi      # 0x1cead
movb $0x0, %al
callq 0x2040
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: baziotis[P]minijava-cpp/./array.h
// Function: Array<llvalue_t, (MEM)4>::reserve(unsigned long)
void reserve(size_t n) {
        assert(len == 0 && cap == 0);
        if (!n) return;
        data = (T *) allocate(n * sizeof(T), mem);
        assert(data);
        len = 0;
        cap = n;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x11(%rbp)
jne 0x16b72
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x16b7b
jmp 0x16b7d
jmp 0x16b9c
leaq 0x5f2d(%rip), %rdi      # 0x1cab1
leaq 0x3e58(%rip), %rsi      # 0x1a9e3
movl $0x2a, %edx
leaq 0x6933(%rip), %rcx      # 0x1d4ca
callq 0x20d0
cmpq $0x0, -0x10(%rbp)
jne 0x16ba5
jmp 0x16bfd
movq -0x10(%rbp), %rdi
shlq $0x5, %rdi
movl $0x4, %esi
callq 0x2340
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
je 0x16bcb
jmp 0x16bea
leaq 0x4332(%rip), %rdi      # 0x1af04
leaq 0x3e0a(%rip), %rsi      # 0x1a9e3
movl $0x2d, %edx
leaq 0x68e5(%rip), %rcx      # 0x1d4ca
callq 0x20d0
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: baziotis[P]minijava-cpp/./typecheck.h
// Function: SerializedHashTable<Local*>::SerializedHashTable()
SerializedHashTable() {
        table.reserve(0);
        serialized = NULL;
        len = 0;
        cap = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x17c00
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17c10
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: VirtualTable::hash(char const*) const
inline ssize_t hash(const char *key) const {
        // Note: We have asserted that the key is not NULL,
        // by definition, which leads to a fast and good
        // multiplicative hasing.

        // Prime factor
        uint32_t factor = 100001029;
        // Non-zero key gets hashed
        uint64_t h = (uint32_t) ((uintptr_t)key * factor);
        h = ((h * (uint64_t) this->nbuckets) >> 32);
        return (ssize_t) h;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5f5e505, -0x14(%rbp) # imm = 0x5F5E505
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq $0x5, %rax
shrq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: FirstBucket::find(char const*) const
ssize_t find(const char *id) const {
        const Bucket *runner = &b;
        ssize_t lim = bucket_cap;
        ssize_t i = nelems;
        while (i > 0) {
            assert(runner);
            ssize_t lim = bucket_cap - 1;
            if (i < bucket_cap) {
                lim = i - 1;
            }
            ssize_t ndx = runner->find(id, lim);
            if (ndx >= 0) {
              return ndx;
            }
            runner = runner->next;
            i -= bucket_cap;
        }
        return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x8, -0x28(%rbp)
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jle 0x16def
cmpq $0x0, -0x20(%rbp)
je 0x16d6f
jmp 0x16d8e
leaq 0x5c3c(%rip), %rdi      # 0x1c9b2
leaq 0x49e1(%rip), %rsi      # 0x1b75e
movl $0xa4, %edx
leaq 0x5c30(%rip), %rcx      # 0x1c9b9
callq 0x20d0
movq $0x7, -0x38(%rbp)
cmpq $0x8, -0x30(%rbp)
jge 0x16da9
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x16e10
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jl 0x16dcf
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16df7
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x16d5b
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: Bucket::find(char const*, long) const
ssize_t find(const char *id, ssize_t lim) const {
        for (ssize_t i = 0; i <= lim; ++i) {
            if (method_ids[i] == id) {
              return indexes[i];
            }
        }
        return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jg 0x16e6f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x16e5f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x16e77
jmp 0x16e61
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x16e30
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: FirstBucket::insert(char const*, long)
void insert(const char *method_id, ssize_t index_in_serial_buf) {
        ssize_t index_in_bucket = nelems % bucket_cap;
        if (nelems != 0 && index_in_bucket == 0) {
            // It may have been allocated from a previous downward
            // tree traversal.
            Bucket *b;
            if (last_bucket->next == NULL) {
                b = new Bucket;
                last_bucket->next = b;
            } else {
                b = last_bucket->next;
            }
            last_bucket = b;
        }
        last_bucket->insert(method_id, index_in_serial_buf, index_in_bucket);
        nelems++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x88(%rax), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq -0x40(%rbp), %rax
movq %rdx, -0x20(%rbp)
cmpq $0x0, 0x88(%rax)
je 0x16fcf
cmpq $0x0, -0x20(%rbp)
jne 0x16fcf
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rax
cmpq $0x0, 0x80(%rax)
jne 0x16faa
movl $0x88, %edi
callq 0x171a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x171c0
jmp 0x16f6e
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq 0x90(%rax), %rax
movq %rcx, 0x80(%rax)
jmp 0x16fc0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x88, %esi
callq 0x2120
jmp 0x17007
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x171e0
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21c0
// File: baziotis[P]minijava-cpp/./hash_table.h
// Function: _HashTable<IdType*, (MEM)3>::find(char const*)
inline T find(const char *key) {
        if (!nbuckets) return NULL;
        assert(key);
        size_t bucket = this->hash(key);
        size_t i = bucket;
        bool wrapped = false;
        while (!wrapped) {
            if (this->ids[i] == key) { 
                return this->data[i];
            } else if (this->ids[i] == nullptr) {
                return nullptr;
            }
            ++i;
            if (i == this->nbuckets) i = 0;
            wrapped = (i == bucket);
        }
        return nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x173db
movq $0x0, -0x8(%rbp)
jmp 0x174b7
cmpq $0x0, -0x18(%rbp)
je 0x173e4
jmp 0x17403
leaq 0x570c(%rip), %rdi      # 0x1caf7
leaq 0x5709(%rip), %rsi      # 0x1cafb
movl $0x5e, %edx
leaq 0x570c(%rip), %rcx      # 0x1cb0a
callq 0x20d0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x174d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movb -0x29(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1742e
jmp 0x174af
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x1745a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x174b7
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x17477
movq $0x0, -0x8(%rbp)
jmp 0x174b7
jmp 0x17479
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
jne 0x1749a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x17420
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/./hash_table.h
// Function: _HashTable<IdType*, (MEM)3>::hash(char const*)
inline size_t hash(const char *key) {
        // Note: We have asserted that the key is not NULL,
        // by definition, which leads to a fast and good
        // multiplicative hasing.

        // Prime factor
        uint32_t factor = 100001029;
        // Non-zero key gets hashed
        size_t h = (uint32_t) ((uintptr_t)key * factor);
        h = (h * (uint64_t) this->nbuckets) >> 32;
        return h;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl $0x5f5e505, -0x14(%rbp) # imm = 0x5F5E505
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edx
imulq %rdx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq (%rcx), %rax
shrq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: baziotis[P]minijava-cpp/./typecheck.h
// Function: IdType::create_children()
void create_children() {
        // Every type can have at most 32 children. That can change,
        // but it's generally realistic.
        constexpr int max_children = 32;
        using ArrType = Array<IdType *, MEM::CHILDREN>;
        void *mem = allocate(sizeof(ArrType), MEM::CHILDREN);
        children = new (mem) ArrType(max_children);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, -0xc(%rbp)
movl $0x18, %edi
movl $0x6, %esi
callq 0x2340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x20, %esi
callq 0x17740
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: baziotis[P]minijava-cpp/./hash_table.h
// Function: _HashTable<Method*, (MEM)3>::reserve(unsigned long)
inline void reserve(size_t nelements) {
        if (nelements) {
            nbuckets = nelements / 0.7;
            ids = (const char **) allocate_zero(nbuckets * sizeof(const char *), mem);
            assert(ids);
            data = (T *) allocate_zero(nbuckets * sizeof(T), mem);
            assert(data);
            for (size_t i = 0; i != nbuckets; ++i) {
                ids[i] = nullptr;
            }
        } else {
            nbuckets = 0;
            ids = NULL;
            data = NULL;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17718
movq -0x20(%rbp), %rax
movaps 0x4122(%rip), %xmm1     # 0x1b720
movq -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4121(%rip), %xmm1     # 0x1b730
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x411a(%rip), %xmm1     # 0x1b740
divsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x4107(%rip), %xmm1     # 0x1b748
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
shlq $0x3, %rdi
movl $0x3, %esi
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x17678
jmp 0x17697
leaq 0x54ec(%rip), %rdi      # 0x1cb6b
leaq 0x5475(%rip), %rsi      # 0x1cafb
movl $0x29, %edx
leaq 0x54dd(%rip), %rcx      # 0x1cb6f
callq 0x20d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
shlq $0x3, %rdi
movl $0x3, %esi
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
je 0x176c0
jmp 0x176df
leaq 0x383d(%rip), %rdi      # 0x1af04
leaq 0x542d(%rip), %rsi      # 0x1cafb
movl $0x2b, %edx
leaq 0x5495(%rip), %rcx      # 0x1cb6f
callq 0x20d0
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
je 0x17716
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x176e7
jmp 0x17733
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./hash_table.h
// Function: _HashTable<IdType*, (MEM)3>::insert(char const*, IdType*)
inline bool insert(const char *key, T value) {
        assert(key);
        assert(nbuckets);
        size_t bucket = this->hash(key);
        size_t i = bucket;
        bool wrapped = false;
        while (!wrapped) {
            if (this->ids[i] == nullptr) {
                this->ids[i] = key;
                this->data[i] = value;
                return true;
            } else if (this->ids[i] == key) {
                printf("\tDUPLICATE: %s\n", key);
                // Duplicates are not allowed
                assert(false);
            }
            ++i;
            if (i == this->nbuckets) i = 0;
            wrapped = (i == bucket); 
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17f65
jmp 0x17f84
leaq 0x4b8b(%rip), %rdi      # 0x1caf7
leaq 0x4b88(%rip), %rsi      # 0x1cafb
movl $0x46, %edx
leaq 0x50ed(%rip), %rcx      # 0x1d06c
callq 0x20d0
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
je 0x17f90
jmp 0x17faf
leaq 0x513e(%rip), %rdi      # 0x1d0d5
leaq 0x4b5d(%rip), %rsi      # 0x1cafb
movl $0x47, %edx
leaq 0x50c2(%rip), %rcx      # 0x1d06c
callq 0x20d0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x174d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x17fda
jmp 0x18099
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1801a
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x20(%rbp), %rdx
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x1(%rbp)
jmp 0x1809d
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x18061
movq -0x18(%rbp), %rsi
leaq 0x50a3(%rip), %rdi      # 0x1d0de
movb $0x0, %al
callq 0x2030
leaq 0x2954(%rip), %rdi      # 0x1a99d
leaq 0x4aab(%rip), %rsi      # 0x1cafb
movl $0x53, %edx
leaq 0x5010(%rip), %rcx      # 0x1d06c
callq 0x20d0
jmp 0x18063
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jne 0x18084
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x17fcc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DanielWochnik[P]CombOptWS2018/graph.cpp
// Function: DHBW::Edge::other_vertex(unsigned long) const
VertexId const & Edge::other_vertex(VertexId v) const
{
	assert(is_adjiazent(v));
	if (v == vertex1())
	{
		return vertex2();
	}
	else 
	{
		return vertex1();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x27f0
testb $0x1, %al
jne 0x2787
jmp 0x2789
jmp 0x27a8
leaq 0x492b(%rip), %rdi      # 0x70bb
leaq 0x4b95(%rip), %rsi      # 0x732c
movl $0x39, %edx
leaq 0x4928(%rip), %rcx      # 0x70cb
callq 0x2120
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2720
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
jne 0x27d4
movq -0x20(%rbp), %rdi
callq 0x2740
movq %rax, -0x8(%rbp)
jmp 0x27e1
movq -0x20(%rbp), %rdi
callq 0x2720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DanielWochnik[P]CombOptWS2018/graph.cpp
// Function: DHBW::Graph::add_edge(unsigned long, unsigned long)
EdgeId Graph::add_edge(VertexId ep1, VertexId ep2)
{
	_edges.emplace_back(num_edges(),ep1,ep2,*this);
	vertex(ep1).add_edge(num_edges()-1);
	vertex(ep2).add_edge(num_edges()-1);

	return num_edges()-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
callq 0x29e0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x3390
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29b0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x29e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x25e0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29b0
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x29e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x29e0
subq $0x1, %rax
addq $0x40, %rsp
popq %rbp
retq
// File: DanielWochnik[P]CombOptWS2018/graph.cpp
// Function: DHBW::Graph::write_to_file_plain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Graph::write_to_file_plain(std::string const & filename)
{
	std::ofstream outfile(filename.c_str());
	
	// Write cities
	outfile << num_vertices();
	
	// Write edges
	for (Edge const & edge : _edges)
	{
		outfile << "\n" << edge.vertex1() << " " << edge.vertex2();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x10, %edx
callq 0x2200
movq -0x250(%rbp), %rdi
callq 0x2920
movq -0x248(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
jmp 0x306f
movq -0x250(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x36b0
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x36e0
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3710
testb $0x1, %al
jne 0x30c3
jmp 0x3182
leaq -0x230(%rbp), %rdi
callq 0x3750
movq %rax, -0x240(%rbp)
leaq 0x419a(%rip), %rsi      # 0x7277
leaq -0x210(%rbp), %rdi
callq 0x21a0
movq %rax, -0x258(%rbp)
jmp 0x30f2
movq -0x240(%rbp), %rdi
callq 0x2720
movq -0x258(%rbp), %rdi
movq (%rax), %rsi
callq 0x2060
movq %rax, -0x260(%rbp)
jmp 0x3116
movq -0x260(%rbp), %rdi
leaq 0x4155(%rip), %rsi      # 0x7279
callq 0x21a0
movq %rax, -0x268(%rbp)
jmp 0x3132
movq -0x240(%rbp), %rdi
callq 0x2740
movq -0x268(%rbp), %rdi
movq (%rax), %rsi
callq 0x2060
jmp 0x314f
jmp 0x3151
leaq -0x230(%rbp), %rdi
callq 0x3770
jmp 0x30a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2280
jmp 0x3197
leaq -0x210(%rbp), %rdi
callq 0x2280
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DanielWochnik[P]CombOptWS2018/main.cpp
// Function: example_function1(DHBW::Graph&)
VertexId example_function1(Graph & g)
{
	// This method is written unneccessary compliceted to give a better feeling of the use of this class
	// EdgeId and GraphId are internally just the same as unsigned int's. I prefer using the aliases for 
	// better readability.
	EdgeId a;
	for (VertexId i = 0; i < g.num_vertices(); ++i)
	{
		// Get the i-th vertex
		Vertex & v = g.vertex(i);
		EdgeId b = 0;
		for (EdgeId e = 0;  e < v.num_edges(); ++ e)
		{
			++b;
		}
		if ( b > a)
		{
			a = b;
		}
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5cde
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29b0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5cb9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5c82
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x5ccb
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5ccd
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5c44
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DanielWochnik[P]CombOptWS2018/main.cpp
// Function: random_path(DHBW::Graph&, unsigned long, unsigned long)
std::vector<VertexId> random_path(Graph & g, VertexId s, VertexId t)
{
	// Create empty vector
	std::vector<VertexId> path;
	// add first vertex, i.e. s, (represented by its id)
	path.push_back(s);
	
	// random walk :D
	VertexId current = s;
	while (current != t)
	{
		// Get vertex from VertexId
		Vertex & v = g.vertex(current);
		// Ask for number of edges
		EdgeId num_edges = v.num_edges();
		// compute random integer in [0,num_edges-1]
		EdgeId rand_id = rand()%num_edges;
		// Take edge (first take id from v, than get edge from g)
		Edge next_edge = g.edge(v.edge(rand_id));
		// Compute next vertex
		current = next_edge.other_vertex(v.id());
		path.push_back(current);
	}
	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x31f0
movq -0x88(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3210
jmp 0x5d37
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x5e5f
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x29b0
movq %rax, -0x98(%rbp)
jmp 0x5d63
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x24f0
movq %rax, -0xa0(%rbp)
jmp 0x5d80
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2080
cltq
movq -0x50(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2510
movq %rax, -0xa8(%rbp)
jmp 0x5dc0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq (%rax), %rsi
callq 0x2a00
movq %rax, -0xb8(%rbp)
jmp 0x5ddf
movq -0xb8(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2580
movq %rax, -0xc0(%rbp)
jmp 0x5e07
movq -0xc0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2760
movq %rax, -0xc8(%rbp)
jmp 0x5e20
movq -0x88(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3210
jmp 0x5e40
jmp 0x5d3f
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4c80
jmp 0x5e85
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5e75
movq -0x88(%rbp), %rdi
callq 0x4c80
movq -0x90(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22e0
nop
// File: DanielWochnik[P]CombOptWS2018/main.cpp
// Function: main
int main()
{	
	// Read graph from input file 
	Graph g("input/graph1.plain");
	// Print to console, std::endl is (almost) equivalent to "\n"
	std::cout << example_function1(g) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22f0
movq -0x70(%rbp), %rdx
leaq 0x13f2(%rip), %rsi      # 0x72a5
leaq -0x50(%rbp), %rdi
callq 0x5f80
jmp 0x5ebe
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x2b70
jmp 0x5ecf
leaq -0x50(%rbp), %rdi
callq 0x2110
leaq -0x51(%rbp), %rdi
callq 0x21f0
leaq -0x30(%rbp), %rdi
callq 0x5c30
movq %rax, -0x78(%rbp)
jmp 0x5ef0
movq -0x78(%rbp), %rsi
movq 0x50dd(%rip), %rdi      # 0xafd8
callq 0x2060
movq %rax, -0x80(%rbp)
jmp 0x5f06
movq -0x80(%rbp), %rdi
movq 0x50b7(%rip), %rsi      # 0xafc8
callq 0x21d0
jmp 0x5f18
leaq -0x30(%rbp), %rdi
callq 0x6030
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5f4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2110
leaq -0x51(%rbp), %rdi
callq 0x21f0
jmp 0x5f6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6030
movq -0x60(%rbp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: DanielWochnik[P]CombOptWS2018/randomgraph.cpp
// Function: DHBW::create_random_graph(DHBW::Graph&, unsigned long, double, double)
void create_random_graph(Graph & g, VertexId n, double p_edge, double directed)
	{
		assert(g.num_vertices() == 0);
		
		// Add vertices
		for (VertexId i = 0; i < n; ++i)
		{
			g.add_vertex();
		}
		
		// add random edges
		for (VertexId i = 0; i < n; ++i)
		{
			for (VertexId j = 0; j < i or (directed and j < n); ++j)
			{
				// Random number in [0,1]
				double const r = ((double) rand() / (RAND_MAX));
				if (p_edge >= r)
				{
					g.add_edge(j,i);
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
cmpq $0x0, %rax
jne 0x631b
jmp 0x633a
leaq 0xfee(%rip), %rdi       # 0x7310
leaq 0xffd(%rip), %rsi       # 0x7326
movl $0x9, %edx
leaq 0x1001(%rip), %rcx      # 0x7336
callq 0x2120
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6363
movq -0x8(%rbp), %rdi
callq 0x2a30
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6342
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6421
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movb $0x1, %al
cmpq -0x30(%rbp), %rcx
movb %al, -0x41(%rbp)
jb 0x63bb
movsd -0x20(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x42(%rbp)
jne 0x63a7
jp 0x63a7
jmp 0x63b5
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x63c4
jmp 0x640e
callq 0x2080
cvtsi2sd %eax, %xmm0
movsd 0xf13(%rip), %xmm1      # 0x72e8
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jb 0x63fb
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2a70
jmp 0x63fd
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x6381
jmp 0x6410
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x636b
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DanielWochnik[P]CombOptWS2018/randomgraph.cpp
// Function: DHBW::write_random_graph_to_file(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void write_random_graph_to_file(VertexId n, std::string const & filename, double directed)
	{
		// Thats a sharp treshhold for connectivity, i.e. the probability that 
		// a random graph with n vertices and p is 
		// 		1, if p > for all p > log(n)/n
		// 		0, if p > for all p < log(n)/n
		// for n -> infinity (that's pretty cool btw!)
		// see also: https://www.math.cmu.edu/~af1p/MAA2005/L2.pdf
		double const p = std::log(n)/n;
		Graph g;
		create_random_graph(g,n,p,directed);
		g.write_to_file(filename);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x64f0
movaps 0xe9b(%rip), %xmm2      # 0x72f0
movq -0x8(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xe9a(%rip), %xmm2      # 0x7300
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2b20
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x62f0
jmp 0x64a4
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0x2fd0
jmp 0x64b5
leaq -0x50(%rbp), %rdi
callq 0x6030
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6030
movq -0x58(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/qm.cc
// Function: main
int main() {

	Blob<string> sa1, sa2; // instantiation will appear elsewhere

	// Blob<int> and its initializer_list constructor 
	// are instantiated in this file
	Blob<int> a1 = {0,1,2,3,4,5,6,7,8,9}; 
	Blob<int> a2(a1);  // copy constructor instantiated in this file

	int i = compare(a1[0], a2[0]); // instantiation will appear elsewhere

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3fd0
leaq -0x28(%rbp), %rdi
callq 0x3fd0
jmp 0x2366
movups 0x7ca7(%rip), %xmm0     # 0xa014
movaps %xmm0, -0x70(%rbp)
movups 0x7c8c(%rip), %xmm0     # 0xa004
movaps %xmm0, -0x80(%rbp)
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, -0x60(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0xa, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x24b0
jmp 0x23ad
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x24e0
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2510
movq %rax, -0xa0(%rbp)
jmp 0x23dd
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0x2510
movq %rax, -0xb0(%rbp)
jmp 0x23f6
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x3f80
movl %eax, -0xb4(%rbp)
jmp 0x2411
movl -0xb4(%rbp), %eax
movl %eax, -0x94(%rbp)
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x25d0
leaq -0x48(%rbp), %rdi
callq 0x25d0
leaq -0x28(%rbp), %rdi
callq 0x25f0
leaq -0x18(%rbp), %rdi
callq 0x25f0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x249d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2494
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x25d0
leaq -0x48(%rbp), %rdi
callq 0x25d0
leaq -0x28(%rbp), %rdi
callq 0x25f0
leaq -0x18(%rbp), %rdi
callq 0x25f0
movq -0x30(%rbp), %rdi
callq 0x21a0
nop
// File: liujan[P]multi_thread_randomforest/main.cpp
// Function: fun()
void fun(){
	ifstream in("train.csv");
	ofstream out("train1.csv");

	string s;
	getline(in, s);
	out << s << endl;
	while (1){
		if (in.eof())
			break;
		getline(in, s);
		double p = rand() * 1.0 / RAND_MAX;
		if (p <= 0.1)
			out << s << endl;
		if (in.peek() == '\n')
			in.get();
	}
	in.close();
	out.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
leaq 0xc97(%rip), %rsi       # 0x10199
leaq -0x208(%rbp), %rdi
movl $0x8, %edx
callq 0x23c0
leaq 0xd1e(%rip), %rsi       # 0x10238
leaq -0x408(%rbp), %rdi
movl $0x10, %edx
callq 0x2260
jmp 0xf52d
leaq -0x438(%rbp), %rdi
movq %rdi, -0x448(%rbp)
callq 0x22e0
movq -0x448(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x2060
jmp 0xf555
leaq -0x408(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x21d0
movq %rax, -0x450(%rbp)
jmp 0xf571
movq -0x450(%rbp), %rdi
movq 0x9a49(%rip), %rsi      # 0x18fc8
callq 0x2230
jmp 0xf586
jmp 0xf588
jmp 0xf58a
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x23d0
movb %al, -0x451(%rbp)
jmp 0xf5aa
movb -0x451(%rbp), %al
testb $0x1, %al
jne 0xf5b6
jmp 0xf601
jmp 0xf6b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
jmp 0xf701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
leaq -0x438(%rbp), %rdi
callq 0x2120
leaq -0x408(%rbp), %rdi
callq 0x2310
jmp 0xf701
leaq -0x208(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x2060
jmp 0xf616
callq 0x2090
cvtsi2sd %eax, %xmm0
movsd 0x9f1(%rip), %xmm1      # 0x10018
mulsd %xmm1, %xmm0
movsd 0x9dd(%rip), %xmm1      # 0x10010
divsd %xmm1, %xmm0
movsd %xmm0, -0x440(%rbp)
movsd 0xbe9(%rip), %xmm0      # 0x10230
ucomisd -0x440(%rbp), %xmm0
jb 0xf684
leaq -0x408(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x21d0
movq %rax, -0x460(%rbp)
jmp 0xf66d
movq -0x460(%rbp), %rdi
movq 0x994d(%rip), %rsi      # 0x18fc8
callq 0x2230
jmp 0xf682
jmp 0xf684
leaq -0x208(%rbp), %rdi
callq 0x20c0
movl %eax, -0x464(%rbp)
jmp 0xf698
movl -0x464(%rbp), %eax
cmpl $0xa, %eax
jne 0xf6b3
leaq -0x208(%rbp), %rdi
callq 0x22a0
jmp 0xf6b1
jmp 0xf6b3
jmp 0xf588
leaq -0x208(%rbp), %rdi
callq 0x2070
jmp 0xf6c6
leaq -0x408(%rbp), %rdi
callq 0x22f0
jmp 0xf6d4
leaq -0x438(%rbp), %rdi
callq 0x2120
leaq -0x408(%rbp), %rdi
callq 0x2310
leaq -0x208(%rbp), %rdi
callq 0x2080
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
leaq -0x208(%rbp), %rdi
callq 0x2080
movq -0x410(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: liujan[P]multi_thread_randomforest/main.cpp
// Function: main
int main(int argc,  char * argv[]) {
	// insert code here...
	
	clock_t start, end;
	start = clock();

	RandomForest forest;
	forest.readTrainSample("train.csv");
	forest.readTestSample("test.csv");
	forest.buildTree(120);
	forest.predict();
	end = clock();
	cout << "runint time is " << (end - start) / CLOCKS_PER_SEC << " second" <<  endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x29290, %rsp          # imm = 0x29290
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2130
movq %rax, -0x18(%rbp)
leaq -0x29208(%rbp), %rdi
callq 0xdbc0
leaq -0x29229(%rbp), %rdi
movq %rdi, -0x29270(%rbp)
callq 0x2380
movq -0x29270(%rbp), %rdx
leaq 0xa2a(%rip), %rsi       # 0x10199
leaq -0x29228(%rbp), %rdi
callq 0xf990
jmp 0xf77d
leaq -0x29208(%rbp), %rdi
leaq -0x29228(%rbp), %rsi
callq 0xe3b0
jmp 0xf792
leaq -0x29228(%rbp), %rdi
callq 0x2120
leaq -0x29229(%rbp), %rdi
callq 0x2250
leaq -0x29261(%rbp), %rdi
movq %rdi, -0x29278(%rbp)
callq 0x2380
movq -0x29278(%rbp), %rdx
leaq 0xa24(%rip), %rsi       # 0x101ef
leaq -0x29260(%rbp), %rdi
callq 0xf990
jmp 0xf7d9
leaq -0x29208(%rbp), %rdi
leaq -0x29260(%rbp), %rsi
callq 0xe750
jmp 0xf7ee
leaq -0x29260(%rbp), %rdi
callq 0x2120
leaq -0x29261(%rbp), %rdi
callq 0x2250
leaq -0x29208(%rbp), %rdi
movl $0x78, %esi
callq 0xdea0
jmp 0xf819
leaq -0x29208(%rbp), %rdi
callq 0xe0c0
jmp 0xf827
callq 0x2130
movq %rax, -0x20(%rbp)
movq 0x97a1(%rip), %rdi      # 0x18fd8
leaq 0xa05(%rip), %rsi       # 0x10243
callq 0x21f0
movq %rax, -0x29280(%rbp)
jmp 0xf84c
movq -0x29280(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
movq %rsi, %rdx
shrq $0x3f, %rdx
sarq $0x12, %rsi
addq %rdx, %rsi
callq 0x23b0
movq %rax, -0x29288(%rbp)
jmp 0xf88a
movq -0x29288(%rbp), %rdi
leaq 0x9bb(%rip), %rsi       # 0x10253
callq 0x21f0
movq %rax, -0x29290(%rbp)
jmp 0xf8a6
movq -0x29290(%rbp), %rdi
movq 0x9714(%rip), %rsi      # 0x18fc8
callq 0x2230
jmp 0xf8bb
movl $0x0, -0x4(%rbp)
leaq -0x29208(%rbp), %rdi
callq 0xeae0
movl -0x4(%rbp), %eax
addq $0x29290, %rsp          # imm = 0x29290
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29238(%rbp)
movl %eax, -0x2923c(%rbp)
jmp 0xf90c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29238(%rbp)
movl %eax, -0x2923c(%rbp)
leaq -0x29228(%rbp), %rdi
callq 0x2120
leaq -0x29229(%rbp), %rdi
callq 0x2250
jmp 0xf96c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29238(%rbp)
movl %eax, -0x2923c(%rbp)
jmp 0xf94c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29238(%rbp)
movl %eax, -0x2923c(%rbp)
leaq -0x29260(%rbp), %rdi
callq 0x2120
leaq -0x29261(%rbp), %rdi
callq 0x2250
jmp 0xf96c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29238(%rbp)
movl %eax, -0x2923c(%rbp)
leaq -0x29208(%rbp), %rdi
callq 0xeae0
movq -0x29238(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
nop
// File: ariannagavioli[P]ALU/AluModule.cpp
// Function: AluModule::AluModule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
AluModule::AluModule(string name, int priority):module(name, priority) {
	string Alu = "Alu";
	
	//This module is the one which triggers the whole system, so it creates a message in its constructor
	if(getName() == Alu){
		message* myMessage = new message();
		myMessage->valid = 1;
		myMessage->timestamp = getTime();
		strcpy(myMessage->source, getName().c_str());
		strcpy(myMessage->dest, "Fetch");
		myMessage->magic_struct = NULL;
		
		sendWithDelay(myMessage, 10);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x20a0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x83d0
jmp 0x2489
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq -0xc8(%rbp), %rax
leaq 0xb898(%rip), %rcx      # 0xdd38
movq %rcx, (%rax)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2260
movq -0xd0(%rbp), %rdx
leaq 0x7c3e(%rip), %rsi      # 0xa0ff
leaq -0x68(%rbp), %rdi
callq 0x21d0
jmp 0x24cc
leaq -0x69(%rbp), %rdi
callq 0x21a0
movq -0xc8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x8470
jmp 0x24ea
leaq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4220
movb %al, -0xd1(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20e0
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x251b
jmp 0x2661
movl $0x30, %edi
callq 0x2180
movq %rax, -0xe0(%rbp)
jmp 0x252e
movq -0xe0(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x42b0
movq -0xe0(%rbp), %rax
movq -0xc8(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movb $0x1, 0x4(%rax)
callq 0x85a0
movl %eax, -0xe4(%rbp)
jmp 0x2575
movq -0xc8(%rbp), %rsi
movl -0xe4(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x98(%rbp), %rax
addq $0xc, %rax
movq %rax, -0xf0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x8470
jmp 0x25ac
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x2080
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x2150
movq -0xf8(%rbp), %rdi
callq 0x20e0
movq -0x98(%rbp), %rdi
addq $0x16, %rdi
leaq 0x7b17(%rip), %rsi      # 0xa103
callq 0x2150
movq -0xc8(%rbp), %rdi
movq -0x98(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x98(%rbp), %rsi
movl $0xa, %edx
callq 0x85c0
jmp 0x261a
jmp 0x2661
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
jmp 0x267f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21a0
jmp 0x2673
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20e0
jmp 0x2673
leaq -0x68(%rbp), %rdi
callq 0x20e0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x42e0
movq -0x40(%rbp), %rdi
callq 0x2250
nopl (%rax,%rax)