LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: MainTypeCheckVisitor::visit(Goal*)
void MainTypeCheckVisitor::visit(Goal *goal) {
    LOG_SCOPE;
    debug_print("MainTypeCheck::Goal\n");
    goal->main_class.accept(this);
    for (IdType *type : this->type_table) {
        if (type->is_defined()) {
            type->accept(this);
        } else {
            // type->loc is going to be the location of its first usage (Check
            // id_to_type()). Ideally, we would like to have all the locations
            // it was used, or some, but this will at least make this a not very
            // bad message.
            typecheck_error(type->loc, "Type `", type->id, "` has not been ",
                            "defined");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34c8
leaq 0x95ee(%rip), %rdi      # 0x138b1
xorl %eax, %eax
callq 0x3539
movq %rbx, %rdi
callq 0xa35a
movq 0x50(%rbx), %r13
testq %r13, %r13
je 0xa32a
movq 0x48(%rbx), %rbp
shlq $0x3, %r13
xorl %r14d, %r14d
leaq 0x929e(%rip), %r15      # 0x1358b
leaq 0x9f2e(%rip), %r12      # 0x14222
movq (%rbp,%r14), %rsi
cmpl $0x0, 0x4(%rsi)
je 0xa309
movq %rbx, %rdi
callq 0xa3c6
jmp 0xa321
movl (%rsi), %edi
movq 0x8(%rsi), %rdx
leaq 0x926e(%rip), %rsi      # 0x13584
movq %r15, %rcx
movq %r12, %r8
callq 0x8bb7
addq $0x8, %r14
cmpq %r14, %r13
jne 0xa2f4
leaq 0x7(%rsp), %rdi
callq 0x34dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa345
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: MainTypeCheckVisitor::visit(MainClass*)
void MainTypeCheckVisitor::visit(MainClass *main_class) {
    LOG_SCOPE;
    debug_print("MainTypeCheck::MainClass\n");
    this->curr_class = this->type_table.main_cls_type;
    this->type_table.main_method->accept(this, this->curr_class->id);
    this->curr_class = NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0x9553(%rip), %rdi      # 0x138c6
xorl %eax, %eax
callq 0x3539
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
movq %rax, 0x80(%rbx)
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0xa48e
movq $0x0, 0x80(%rbx)
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: MainTypeCheckVisitor::visit(IdType*)
void MainTypeCheckVisitor::visit(IdType *type) {
    LOG_SCOPE;
    assert(type->is_IdType());
    assert(type->is_defined());
    debug_print("MainTypeCheck::IdType %s\n", type->id);

    this->curr_class = type;
    for (Method *method : type->methods) {
        method->accept(this, type->id);
    }
    this->curr_class = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
testq %r14, %r14
je 0xa458
cmpl $0x4, 0x4(%r14)
jne 0xa458
movq 0x8(%r14), %rsi
leaq 0x9523(%rip), %rdi      # 0x1391d
xorl %eax, %eax
callq 0x3539
movq %r14, 0x80(%rbx)
movq 0x60(%r14), %r15
testq %r15, %r15
je 0xa435
movq 0x58(%r14), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa48e
addq $0x8, %r13
cmpq %r13, %r15
jne 0xa41c
movq $0x0, 0x80(%rbx)
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9481(%rip), %rdi      # 0x138e0
leaq 0x8f98(%rip), %rsi      # 0x133fe
leaq 0x9485(%rip), %rcx      # 0x138f2
movl $0x2ea, %edx            # imm = 0x2EA
callq 0x20b0
jmp 0xa479
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: compatible_types(Type*, Type*)
static bool compatible_types(Type *lhs, Type *rhs) {
    if (lhs == rhs) return true;
    IdType *ty1 = lhs->is_IdType();
    IdType *ty2 = rhs->is_IdType();
    if (ty1 && ty2) {
        IdType *runner = ty2;
        while (runner->parent) {
            runner = runner->parent;
            if (runner == ty1) {
                return true;
            }
            // Cyclic inheritance, we issue error elsewhere.
            if (runner == ty2) break;
        }
        return false;
    }
    return false;
}

// Assembly:
cmpq %rsi, %rdi
je 0xb319
xorl %eax, %eax
cmpl $0x4, 0x4(%rdi)
cmovneq %rax, %rdi
cmpl $0x4, 0x4(%rsi)
movl $0x0, %ecx
cmoveq %rsi, %rcx
testq %rdi, %rdi
sete %dl
testq %rcx, %rcx
sete %r8b
orb %dl, %r8b
jne 0xb318
movq 0x78(%rsi), %rsi
testq %rsi, %rsi
je 0xb316
cmpq %rdi, %rsi
je 0xb319
cmpq %rcx, %rsi
jne 0xb303
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: lookup_local(char const*, Method*, IdType*)
static Local *lookup_local(const char *id, Method *method, IdType *cls) {
    // Check current method's locals (vars and params).
    Local *local = method->locals.find(id);
    if (local) {
        return local;
    }
    // Check current class's fields.
    local = cls->fields.find(id);
    if (local) {
        return local;
    }
    // Check parent's fields (account for cyclic inheritance).
    IdType *runner = cls;
    while (runner->parent) {
        runner = runner->parent;
        local = runner->fields.find(id);
        if (local) {
            return local;
        }
        // Cyclic inheritance, we issue error elsewhere.
        if (runner == cls) break;
    }
    return NULL;
}

// Assembly:
pushq %rax
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0xd0f5
testq %rdi, %rdi
je 0xd1b8
imull $0x5f5e505, %edi, %ecx  # imm = 0x5F5E505
imulq %rax, %rcx
shrq $0x20, %rcx
movq 0x20(%rsi), %r8
xorl %r10d, %r10d
movq %rcx, %r9
movq (%r8,%r9,8), %r11
cmpq %rdi, %r11
je 0xd0e4
testq %r11, %r11
je 0xd0f5
incq %r9
cmpq %rax, %r9
cmoveq %r10, %r9
cmpq %rcx, %r9
jne 0xd0c5
jmp 0xd0f5
movq 0x28(%rsi), %rax
movq (%rax,%r9,8), %rax
testq %rax, %rax
jne 0xd1b6
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0xd14b
testq %rdi, %rdi
je 0xd1b8
imull $0x5f5e505, %edi, %ecx  # imm = 0x5F5E505
imulq %rax, %rcx
shrq $0x20, %rcx
movq 0x18(%rdx), %rsi
xorl %r9d, %r9d
movq %rcx, %r8
movq (%rsi,%r8,8), %r10
cmpq %rdi, %r10
je 0xd13e
testq %r10, %r10
je 0xd14b
incq %r8
cmpq %rax, %r8
cmoveq %r9, %r8
cmpq %rcx, %r8
jne 0xd11f
jmp 0xd14b
movq 0x20(%rdx), %rax
movq (%rax,%r8,8), %rax
testq %rax, %rax
jne 0xd1b6
imull $0x5f5e505, %edi, %ecx  # imm = 0x5F5E505
movq %rdx, %rsi
movq 0x78(%rsi), %rsi
testq %rsi, %rsi
je 0xd1b4
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0xd1af
testq %rdi, %rdi
je 0xd1b8
movq %rax, %r8
imulq %rcx, %r8
shrq $0x20, %r8
movq 0x18(%rsi), %r10
movq %r8, %r9
movq (%r10,%r9,8), %r11
cmpq %rdi, %r11
je 0xd1a2
testq %r11, %r11
je 0xd1af
incq %r9
cmpq %rax, %r9
movl $0x0, %r11d
cmoveq %r11, %r9
cmpq %r8, %r9
jne 0xd17d
jmp 0xd1af
movq 0x20(%rsi), %rax
movq (%rax,%r9,8), %rax
testq %rax, %rax
jne 0xd1b6
cmpq %rdx, %rsi
jne 0xd154
xorl %eax, %eax
popq %rcx
retq
leaq 0x75c6(%rip), %rdi      # 0x14785
leaq 0x75c3(%rip), %rsi      # 0x14789
leaq 0x7b67(%rip), %rcx      # 0x14d34
movl $0x5e, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: typecheck_and_helper(bool, Expression*, MainTypeCheckVisitor*, Type*, Type*)
static Type *typecheck_and_helper(bool is_correct, Expression *expr,
                                  MainTypeCheckVisitor *v, Type *boolty, Type *undefinedty) {
    Type *ty = expr->accept(v);
    if (ty->kind == TY::UNDEFINED) {
        return undefinedty;
    }
    if (ty != boolty) {
        typecheck_error(expr->loc, "Bad right operand for binary operator `&&`. Operand ",
                        "of boolean type was expected, found: `", ty->name(), "`");
        is_correct = false;
    }
    if (is_correct) {
        return boolty;
    }
    return undefinedty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq %rdx, %rdi
callq 0xb31c
cmpl $0x0, 0x4(%rax)
je 0xd2ec
cmpq %r14, %rax
je 0xd2e5
movl (%r15), %ebp
movq %rax, %rdi
callq 0x83da
leaq 0x778a(%rip), %rsi      # 0x14a55
leaq 0x6adf(%rip), %rdx      # 0x13db1
leaq 0x5678(%rip), %r8       # 0x12951
movl %ebp, %edi
movq %rax, %rcx
callq 0x8bb7
jmp 0xd2ec
testb %bpl, %bpl
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: MainTypeCheckVisitor::visit(BlockStatement*)
void MainTypeCheckVisitor::visit(BlockStatement *block_stmt) {
    LOG_SCOPE;
    debug_print("MainTypeCheck::BlockStatement\n");
    for (Statement *stmt : block_stmt->block) {
        stmt->accept(this);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34c8
leaq 0x6cb8(%rip), %rdi      # 0x14179
xorl %eax, %eax
callq 0x3539
movq 0x18(%r14), %r15
testq %r15, %r15
je 0xd4f2
movq 0x20(%r14), %r14
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r12
cmpq %r12, %r15
jne 0xd4dc
leaq 0x7(%rsp), %rdi
callq 0x34dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd50a
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: track_while_assignment_for_expr(Expression*, Array<WhileAssign, (MEM)4>)
bool track_while_assignment_for_expr(Expression *expr, FuncArr<WhileAssign> track_buf) {
    switch (expr->kind) {
    case EXPR::ID:
    {
        for (WhileAssign& wa : track_buf) {
            Local *local = wa.local;
            if (expr->id == local->id) {
                if (!wa.used) {
                    if (!wa.assigned) {
                        wa.used = 1;
                    } else {
                        wa.used = 2;
                    }
                }
                break;
            }
        }
    } break;
    case EXPR::ARR_ALLOC:
    case EXPR::ARR_LEN:
    case EXPR::NOT:
    {
        track_while_assignment_for_expr(expr->e1, track_buf);
    } break;
    case EXPR::AND:
    case EXPR::CMP:
    case EXPR::PLUS:
    case EXPR::MINUS:
    case EXPR::TIMES:
    case EXPR::ARR_LOOK:
    {
        BinaryExpression *be = (BinaryExpression *) expr;
        track_while_assignment_for_expr(be->e1, track_buf);
        track_while_assignment_for_expr(be->e2, track_buf);
    } break;
    case EXPR::MSG_SEND:
    {
        BinaryExpression *be = (BinaryExpression *) expr;
        track_while_assignment_for_expr(be->e1, track_buf);
        for (Expression *e : be->msd->expr_list) {
            track_while_assignment_for_expr(e, track_buf);
        }
    } break;
    default: break;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x80(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x4caf(%rip), %r12      # 0x132c4
leaq 0x38(%rsp), %r13
movl 0x4(%rbx), %eax
decl %eax
cmpl $0xd, %eax
ja 0xe714
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0xe5f1
movl $0x18, %eax
movq %r13, %rcx
jmp 0xe65d
movl $0x10, %eax
movq %r15, %rcx
movq (%rbx,%rax), %rbx
movq 0x10(%r14), %rax
movq %rax, 0x10(%rcx)
movups (%r14), %xmm0
movups %xmm0, (%rcx)
jmp 0xe61a
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0xe5f1
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0xe714
movq 0x18(%rax), %r15
shlq $0x3, %rbx
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0xe5f1
addq $0x8, %r12
cmpq %r12, %rbx
jne 0xe6a4
jmp 0xe714
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0xe714
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rsi
shlq $0x4, %rdx
xorl %ecx, %ecx
movq (%rax,%rcx), %rdi
cmpq (%rdi), %rsi
je 0xe6f4
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe6e0
jmp 0xe714
movb 0x8(%rax,%rcx), %dl
testb $0xc, %dl
jne 0xe714
testb $0x3, %dl
setne %sil
shlb $0x2, %sil
addb %dl, %sil
addb $0x4, %sil
movb %sil, 0x8(%rax,%rcx)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: get_track_buf(SerializedHashTable<Local*>)
FuncArr<WhileAssign> get_track_buf(SerializedHashTable<Local*> locals) {
    FuncArr<WhileAssign> track_buf(locals.len);
    size_t i = 0;
    for (Local *lo : locals) {
        // Initialize its entry with its local and dumb
        // values for `assigned` and `used` (they will be overriden).
        track_buf.push({lo, 0, 0});
        ++i;
    }
    return track_buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x103be
testq %r14, %r14
je 0xe9bd
movq 0x48(%rsp), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xfa28
addq $0x8, %r12
cmpq %r12, %r14
jne 0xe9a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: MainTypeCheckVisitor::visit(PrintStatement*)
void MainTypeCheckVisitor::visit(PrintStatement *print_stmt) {
    LOG_SCOPE;
    debug_print("MainTypeCheck::PrintStatement\n");
    // A print statement can have only integer.
    Type *ty = print_stmt->to_print->accept(this);
    poison_stmt(ty);
    if (ty != this->type_table.int_type) {
        typecheck_error(print_stmt->to_print->loc,
                        "Print statement accepts only integer expressions.");
    }
    /// Codegen ///
    llvalue_t to_print = __expr_context.llval;
    cgen_print_stmt(to_print);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27(%rsp), %rdi
callq 0x34c8
leaq 0x53bb(%rip), %rdi      # 0x145b9
xorl %eax, %eax
callq 0x3539
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xb31c
cmpl $0x0, 0x4(%rax)
je 0xf24c
cmpq 0x10(%r14), %rax
je 0xf22f
movq 0x10(%rbx), %rax
movl (%rax), %edi
leaq 0x53ae(%rip), %rsi      # 0x145d8
callq 0xd1d7
leaq 0xb782(%rip), %rax      # 0x1a9b8
movups 0x8(%rax), %xmm0
movups 0x18(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x4952
leaq 0x27(%rsp), %rdi
callq 0x34dc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xf262
jmp 0xf262
movq %rax, %rbx
leaq 0x27(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: void typecheck_error_no_ln<char const*, char const*, char const*, char const*>(location_t, char const*, char const*, char const*, char const*)
void typecheck_error_no_ln(location_t __loc, Args... args) {
    ++num_global_typecheck_errors;
    log(__loc);
    yellow_on();
    bold_on();
    log(" Semantic Error: ");
    bold_off();
    yellow_off();
    log(args...);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
incl 0xd6a8(%rip)            # 0x1ca88
movq %rsi, %r12
movl %edi, %edx
leaq 0xb654(%rip), %rax      # 0x1aa40
movq (%rax), %rsi
leaq 0x287c(%rip), %rdi      # 0x11c72
xorl %eax, %eax
callq 0x2030
leaq 0xb634(%rip), %r13      # 0x1aa38
movb 0x1(%r13), %al
cmpb $0x1, %al
jne 0xf41e
leaq 0x57ea(%rip), %rdi      # 0x14bfd
xorl %eax, %eax
callq 0x2030
movb 0x1(%r13), %al
testb $0x1, %al
je 0xf430
leaq 0x2852(%rip), %rdi      # 0x11c7b
xorl %eax, %eax
callq 0x2030
leaq 0x1f7d(%rip), %rdi      # 0x113b4
leaq 0x57ad(%rip), %rsi      # 0x14beb
xorl %eax, %eax
callq 0x2030
movb 0x1(%r13), %al
cmpb $0x1, %al
jne 0xf45f
leaq 0x20b1(%rip), %rdi      # 0x11505
xorl %eax, %eax
callq 0x2030
movb 0x1(%r13), %al
testb $0x1, %al
je 0xf471
leaq 0x209b(%rip), %rdi      # 0x11505
xorl %eax, %eax
callq 0x2030
leaq 0x1f3c(%rip), %rdi      # 0x113b4
movq %r12, %rsi
xorl %eax, %eax
callq 0x2030
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf2e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/typecheck.cpp
// Function: VirtualTable::insert(Method*, char const*)
void insert(Method *method, const char *enclosing) {
        assert(method);
        // Keep index that it will be pushed in the serial buffer.
        ssize_t index = vmethods.len;
        vmethods.push({method, enclosing});
        // Insert it into the table (giving it an index to keep
        // in the serial buffer)
        const char *method_id = method->id;
        ssize_t val = this->hash(method_id);
        buckets[val].insert(method_id, index);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xf4ec
movq %rsi, %r14
movq %rdi, %rbx
addq $0x1308, %rdi           # imm = 0x1308
movq 0x1310(%rbx), %r15
callq 0xfce6
movq (%r14), %rsi
movl $0xbebca0a0, %eax       # imm = 0xBEBCA0A0
imulq %rsi, %rax
shrq $0x20, %rax
andl $0x1f, %eax
imulq $0x98, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0x8, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xfd34
leaq 0x427e(%rip), %rdi      # 0x13771
leaq 0x3f04(%rip), %rsi      # 0x133fe
leaq 0x5174(%rip), %rcx      # 0x14675
movl $0xde, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
testq %rsi, %rsi
je 0xf6b2
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
movq $0x0, 0x20(%rdi)
shlq $0x3, %rsi
movq %rsi, %rdi
movl $0x3, %esi
callq 0x22dc
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xf6b4
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xf6a2
movq %rax, %xmm0
punpckldq 0x3d0d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3d15(%rip), %xmm0     # 0x13330
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x3db1(%rip), %xmm1     # 0x133e0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x3da5(%rip), %xmm1     # 0x133e8
cvttsd2si %xmm1, %rdi
andq %rcx, %rdi
orq %rax, %rdi
movq %rdi, (%rbx)
shlq $0x3, %rdi
movl $0x3, %esi
callq 0x23ef
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xf6d3
movq (%rbx), %rdi
shlq $0x3, %rdi
movl $0x3, %esi
callq 0x23ef
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xf6f2
movq (%rbx), %rax
testq %rax, %rax
je 0xf6b2
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xf68c
jmp 0xf6b2
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
leaq 0x5267(%rip), %rdi      # 0x14922
leaq 0x526b(%rip), %rsi      # 0x1492d
leaq 0x55a6(%rip), %rcx      # 0x14c6f
movl $0x2d, %edx
callq 0x20b0
leaq 0x511f(%rip), %rdi      # 0x147f9
leaq 0x50a8(%rip), %rsi      # 0x14789
leaq 0x51d9(%rip), %rcx      # 0x148c1
movl $0x29, %edx
callq 0x20b0
leaq 0x341c(%rip), %rdi      # 0x12b15
leaq 0x5089(%rip), %rsi      # 0x14789
leaq 0x51ba(%rip), %rcx      # 0x148c1
movl $0x2b, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x476a
movq %rax, %r14
movq %r15, %rdi
callq 0x2090
leaq 0xa(%rax), %r12
movq %r12, %rdi
movl $0x4, %esi
callq 0x22dc
movq %rax, %r13
movq %r12, %rdi
movl $0x4, %esi
callq 0x22dc
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
callq 0x20f0
leaq 0x5259(%rip), %rsi      # 0x14a8a
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xf93e
addq $0x8, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf93e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq 0x8(%rdi), %rax
cmpq $-0x1, %rax
je 0xf89f
cmpq (%rdi), %rax
jae 0xf8be
leaq 0x10(%rsp), %rcx
leaq 0x1(%rax), %rdx
movq 0x10(%rdi), %rsi
shlq $0x5, %rax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsi,%rax)
movups %xmm0, (%rsi,%rax)
movq %rdx, 0x8(%rdi)
popq %rax
retq
leaq 0x50f9(%rip), %rdi      # 0x1499f
leaq 0x4fb1(%rip), %rsi      # 0x1485e
leaq 0x565d(%rip), %rcx      # 0x14f11
movl $0x22, %edx
callq 0x20b0
leaq 0x513c(%rip), %rdi      # 0x14a01
leaq 0x4f92(%rip), %rsi      # 0x1485e
leaq 0x563e(%rip), %rcx      # 0x14f11
movl $0x23, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xf9a7
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0xf9c6
movq %rdx, %r15
movq %rsi, %r14
cmpq $-0x1, %rdx
jne 0xf968
callq 0x476a
movq %rax, %r15
movq %r14, %rdi
callq 0x2090
leaq 0x14(%rax), %rdi
movl $0x4, %esi
callq 0x22dc
movq %rax, %r12
leaq 0x51bd(%rip), %rsi      # 0x14b45
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2040
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x514c(%rip), %rdi      # 0x14afa
leaq 0x514a(%rip), %rsi      # 0x14aff
leaq 0x514c(%rip), %rcx      # 0x14b08
movl $0x11, %edx
callq 0x20b0
leaq 0x516c(%rip), %rdi      # 0x14b39
leaq 0x512b(%rip), %rsi      # 0x14aff
leaq 0x512d(%rip), %rcx      # 0x14b08
movl $0x12, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
orq 0x8(%rdi), %rax
jne 0xfad7
movq %rsi, %rbx
testq %rsi, %rsi
je 0xfacf
movq %rdi, %r14
movq %rbx, %rdi
shlq $0x5, %rdi
movl $0x4, %esi
callq 0x22dc
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0xfaf6
movq $0x0, 0x8(%r14)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4c61(%rip), %rdi      # 0x1473f
leaq 0x4d79(%rip), %rsi      # 0x1485e
leaq 0x5624(%rip), %rcx      # 0x15110
movl $0x2a, %edx
callq 0x20b0
leaq 0x3018(%rip), %rdi      # 0x12b15
leaq 0x4d5a(%rip), %rsi      # 0x1485e
leaq 0x5605(%rip), %rcx      # 0x15110
movl $0x2d, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq 0x88(%rdi), %rcx
testq %rcx, %rcx
jle 0xfcbd
movl $0x7, %edx
testq %rdi, %rdi
je 0xfcc6
leaq -0x1(%rcx), %rax
cmpq $0x8, %rcx
cmovaeq %rdx, %rax
incq %rax
xorl %r8d, %r8d
cmpq %rsi, (%rdi,%r8,8)
je 0xfc9f
incq %r8
cmpq %r8, %rax
jne 0xfc8f
jmp 0xfca9
movq 0x40(%rdi,%r8,8), %rax
testq %rax, %rax
jns 0xfcc4
movq 0x80(%rdi), %rdi
leaq -0x8(%rcx), %rax
cmpq $0x8, %rcx
movq %rax, %rcx
jg 0xfc78
movq $-0x1, %rax
popq %rcx
retq
leaq 0x4973(%rip), %rdi      # 0x14640
leaq 0x372a(%rip), %rsi      # 0x133fe
leaq 0x496c(%rip), %rcx      # 0x14647
movl $0xa4, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/./buf.h
// Function: Buf<VMethod>::push(VMethod)
void push(T v) {
        size_t new_len = len + 1;
        if(new_len > cap) _grow(new_len);
        data[len] = v;
        len = new_len;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %r12
cmpq (%rdi), %r12
jbe 0xfd13
movq %r14, %rdi
movq %r12, %rsi
callq 0xfdee
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
shlq $0x4, %rax
movq %r15, (%rcx,%rax)
movq %rbx, 0x8(%rcx,%rax)
movq %r12, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x88(%rdi), %r12
movq 0x90(%rdi), %rax
leaq 0x7(%r12), %rcx
testq %r12, %r12
cmovnsq %r12, %rcx
sete %dl
andq $-0x8, %rcx
subq %rcx, %r12
setne %cl
orb %dl, %cl
jne 0xfdad
movq 0x80(%rax), %rax
testq %rax, %rax
jne 0xfda4
movl $0x88, %edi
movl $0x5, %esi
callq 0x22dc
movq $0x0, 0x80(%rax)
movq 0x90(%r14), %rcx
movq %rax, 0x80(%rcx)
movq %rax, 0x90(%r14)
jmp 0xfdb3
cmpq $0x8, %r12
jae 0xfdcf
movq %r15, (%rax,%r12,8)
movq %rbx, 0x40(%rax,%r12,8)
incq 0x88(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4900(%rip), %rdi      # 0x146d6
leaq 0x3621(%rip), %rsi      # 0x133fe
leaq 0x4927(%rip), %rcx      # 0x1470b
movl $0x75, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
movq %rax, %rdx
callq 0x2e50
movq 0x8(%rsp), %rsi
movq %rsi, (%rsp)
cmpq %r14, %rsi
je 0x342a
leaq 0x10(%rsp), %r12
movq %r15, %rdi
callq 0x2632
movq %rax, %rbp
movq %rax, %rdi
callq 0x23dc
movq %rax, %r13
callq 0x2050
cltq
xorl %edx, %edx
divq %r13
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x23ea
movq (%rax), %rsi
movq %r15, %rdi
callq 0x268a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rbp, %rdi
callq 0x2424
movq %r12, %rdi
movq %rax, %rsi
callq 0x2526
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3412
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x341d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x2e50
movq (%rsp), %rsi
cmpq %r14, %rsi
jne 0x3398
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3442
jmp 0x3442
jmp 0x3442
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3459
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe24(%rip), %rsi       # 0x429c
leaq 0xe2f(%rip), %rdx       # 0x42ae
leaq 0x8(%rsp), %rdi
callq 0x3578
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x2806
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x34b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x32e4
movq 0x2b16(%rip), %rdi      # 0x5fd8
movq %rax, %rsi
callq 0x20b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x350b
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2d14
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x354d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x354d
movq %rax, %rbx
jmp 0x354d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3556
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25ce
testq %rax, %rax
jne 0x36db
testq %rbx, %rbx
je 0x36cf
movq %rbx, %r15
movq %r14, %rdi
callq 0x26c6
decq %r15
jne 0x3647
xorl %r15d, %r15d
testq %r15, %r15
jne 0x366e
movsd 0x8(%rsp), %xmm0
ucomisd 0xc7e(%rip), %xmm0      # 0x42e8
jne 0x366e
jnp 0x36c7
xorl %r12d, %r12d
callq 0x2050
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0xc5b(%rip), %xmm0      # 0x42e0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x369f
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x270e
movsd 0x8(%rsp), %xmm0
ucomisd 0xc3b(%rip), %xmm0      # 0x42e8
setp %cl
setne %al
incq %r12
cmpq %rbx, %r12
setb %dl
cmpq %r15, %r12
jb 0x3671
orb %cl, %al
andb %dl, %al
jne 0x3671
incq %r15
cmpq %rbx, %r15
jne 0x3657
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc2e(%rip), %rdi       # 0x4310
leaq 0xc3d(%rip), %rsi       # 0x4326
leaq 0xc46(%rip), %rcx       # 0x4336
movl $0x9, %edx
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %r14
movq %rdi, %xmm1
punpckldq 0xbd7(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xbdf(%rip), %xmm1      # 0x4300
movq %rsi, %rbx
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
callq 0x20f0
divsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x27f6
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x3610
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2b60
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x378d
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
leaq 0x20(%rsp), %rdi
callq 0x2d14
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3556
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x78, %rsp
leaq -0x40(%rbp), %rdi
callq 0x2876
leaq -0x30(%rbp), %rdi
callq 0x2876
movups 0x2cd6(%rip), %xmm0     # 0x5014
leaq -0x70(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movups 0x2cb7(%rip), %xmm0     # 0x5004
movaps %xmm0, (%rax)
movabsq $0x900000008, %rcx      # imm = 0x900000008
movq %rcx, 0x20(%rax)
leaq -0x80(%rbp), %rcx
movq %rax, (%rcx)
movq $0xa, 0x8(%rcx)
leaq -0x18(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x20(%rbp), %rsi
leaq -0x9(%rbp), %rdx
callq 0x2564
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
testq %rax, %rax
je 0x23b0
movq 0x5c26(%rip), %rcx      # 0x7fc8
cmpb $0x0, (%rcx)
je 0x23ac
incl 0x8(%rax)
jmp 0x23b0
lock
incl 0x8(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2462
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x2462
movq %rbx, %rdi
movq %rax, %rsi
callq 0x285c
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x23e2
callq 0x24f8
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x23f0
callq 0x24f8
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x23fe
callq 0x24f8
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x240c
callq 0x24f8
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x243e
movq %rax, %rbx
jmp 0x244c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2430
callq 0x24f8
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x243e
callq 0x24f8
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x244c
callq 0x24f8
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x245a
callq 0x24f8
movq %rbx, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/liujan[P]multi_thread_randomforest/RandomForest.cpp
// Function: RandomForest::buildTree(int)
bool RandomForest::buildTree(int num){
	if (all_samples.empty()){
		cout << "[Error] all sample is empty" << endl;
		return false;
	}

	memset(result, 0, sizeof(result));
	memset(r, 0, sizeof(r));

	for (int i = 0; i < num; i+=numOfThread){
		pthread_t thread[numOfThread];
		M *m = new M[numOfThread];
		//memset(flag, false, sizeof(flag));
		for (int j = 0; j < numOfThread; j++){
			m[j].rf = this;
			m[j].i = j;
			pthread_create(&thread[j], NULL, build, &(m[j]));
		}
		for (int j = 0; j < numOfThread; j++)
			pthread_join(thread[j], NULL);
		
		delete[] m;
	}
	

	for (int i = 0; i < numOfTest; i++){
		for (int j = 0; j < numOfTypes + 1; j++){
			for (int k = 0; k < numOfThread; k++){
				r[i][j] += result[k][i][j];
			}
		}
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x50eb
movl %esi, %ebx
movq %rdi, %r12
movq %r15, -0x40(%rbp)
movq %r14, -0x48(%rbp)
leaq 0x51f5(%rip), %rdi      # 0xa1d0
xorl %r14d, %r14d
movl $0x148da0, %edx         # imm = 0x148DA0
xorl %esi, %esi
callq 0x2100
leaq 0x30(%r12), %rdi
movl $0x291b4, %edx          # imm = 0x291B4
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x2100
testl %ebx, %ebx
jle 0x508a
leaq -0x234(%rip), %r13      # 0x4dda
movl %ebx, -0x2c(%rbp)
movq %r14, -0x58(%rbp)
movl $0x80, %edi
callq 0x2030
movq %rax, %r15
movq %rax, -0x50(%rbp)
leaq -0xa0(%rbp), %r14
xorl %ebx, %ebx
movq %r12, (%r15)
movl %ebx, 0x8(%r15)
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2300
incq %rbx
addq $0x8, %r14
addq $0x10, %r15
cmpq $0x8, %rbx
jne 0x502f
xorl %ebx, %ebx
movq -0xa0(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x21b0
incq %rbx
cmpq $0x8, %rbx
jne 0x5059
movq -0x50(%rbp), %rdi
callq 0x2250
movq -0x58(%rbp), %r14
addl $0x8, %r14d
movl -0x2c(%rbp), %ebx
cmpl %ebx, %r14d
jl 0x5011
xorl %eax, %eax
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %r15
leaq 0x5135(%rip), %r10      # 0xa1d0
movq -0x38(%rbp), %r11
imulq $0x6c, %rax, %rcx
addq %r11, %rcx
movq %r10, %rdx
xorl %esi, %esi
leaq (%rcx,%rsi,4), %rdi
movl (%rdi), %r8d
movq $-0x148da0, %r9         # imm = 0xFFEB7260
addl 0x148da0(%rdx,%r9), %r8d
movl %r8d, (%rdi)
addq $0x291b4, %r9           # imm = 0x291B4
jne 0x50b9
incq %rsi
addq $0x4, %rdx
cmpq $0x1b, %rsi
jne 0x50ab
incq %rax
addq $0x6c, %r10
cmpq $0x617, %rax            # imm = 0x617
jne 0x509f
jmp 0x512d
movq 0x4ee6(%rip), %rbx      # 0x9fd8
leaq 0x2047(%rip), %rsi      # 0x7140
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
cmpq %r15, %r14
setne %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x13fd(%rip), %rsi      # 0x71b4
leaq -0x250(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2310
leaq 0x1486(%rip), %rsi      # 0x7258
leaq -0x450(%rbp), %rdi
movl $0x10, %edx
callq 0x2210
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq -0x250(%rbp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %edx
leaq -0x250(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2320
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x450(%rbp), %rdi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x230(%rbp,%rax)
jne 0x5f40
leaq (%rax,%rbp), %rdi
addq $-0x250, %rdi           # imm = 0xFDB0
leaq -0x250(%rbp), %rbx
leaq -0x48(%rbp), %r14
leaq -0x450(%rbp), %r15
movl $0xa, %esi
callq 0x21d0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2320
callq 0x2090
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x1145(%rip), %xmm0     # 0x7008
movsd 0x1385(%rip), %xmm1     # 0x7250
ucomisd %xmm0, %xmm1
jb 0x5f0b
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x2220
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x20d0
cmpl $0xa, %eax
jne 0x5f20
movq %rbx, %rdi
callq 0x2240
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %rdi
addq $-0x250, %rdi           # imm = 0xFDB0
testb $0x2, 0x20(%rdi)
je 0x5e97
leaq -0x250(%rbp), %rdi
callq 0x2060
leaq -0x450(%rbp), %rdi
callq 0x2270
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5f6d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21f0
movq 0x405c(%rip), %rax      # 0x9fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x448(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x450(%rbp,%rcx)
callq 0x2190
leaq -0x358(%rbp), %rdi
callq 0x20b0
leaq -0x250(%rbp), %rdi
callq 0x2080
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5fee
jmp 0x5fca
jmp 0x5fca
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5fe2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21f0
leaq -0x450(%rbp), %rdi
callq 0x2290
leaq -0x250(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x29230, %rsp          # imm = 0x29230
callq 0x2130
movq %rax, %rbx
leaq -0x29238(%rbp), %rdi
callq 0x4db4
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1181(%rip), %rsi      # 0x71b4
leaq 0x1183(%rip), %rdx      # 0x71bd
leaq -0x50(%rbp), %rdi
callq 0x61b6
leaq -0x29238(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x539c
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x6068
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21f0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1193(%rip), %rsi      # 0x720a
leaq 0x1194(%rip), %rdx      # 0x7212
leaq -0x30(%rbp), %rdi
callq 0x61b6
leaq -0x29238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x56f0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x60ac
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21f0
leaq -0x29238(%rbp), %rdi
movl $0x78, %esi
callq 0x4fa6
leaq -0x29238(%rbp), %rdi
callq 0x5142
callq 0x2130
movq %rax, %r14
movq 0x3f00(%rip), %rdi      # 0x9fd8
leaq 0x1184(%rip), %rsi      # 0x7263
movl $0xf, %edx
callq 0x2220
subq %rbx, %r14
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0x3ec7(%rip), %rdi      # 0x9fd8
callq 0x21c0
movq %rax, %rbx
leaq 0x1153(%rip), %rsi      # 0x7273
movl $0x7, %edx
movq %rax, %rdi
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
leaq -0x29238(%rbp), %rdi
callq 0x5a3e
xorl %eax, %eax
addq $0x29230, %rsp          # imm = 0x29230
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x61a1
movq -0x20(%rbp), %rsi
jmp 0x6192
jmp 0x619e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x61a1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21f0
jmp 0x61a1
jmp 0x619e
movq %rax, %rbx
leaq -0x29238(%rbp), %rdi
callq 0x5a3e
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x34f2
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x460c
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x23ee
callq 0x2120
leaq 0x594b(%rip), %rax      # 0x7d40
movq %rax, (%rbx)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2cf6(%rip), %rsi      # 0x50ff
leaq 0x2cf2(%rip), %rdx      # 0x5102
leaq 0x28(%rsp), %rdi
callq 0x3588
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x468c
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x2452
movq 0x8(%rsp), %r14
testq %rdx, %rdx
je 0x245b
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bpl
jmp 0x245e
movq 0x8(%rsp), %r14
xorl %ebp, %ebp
jmp 0x245e
movb $0x1, %bpl
leaq 0x18(%rsp), %r13
cmpq %r13, %r14
je 0x2470
movq %r14, %rdi
callq 0x2120
testb %bpl, %bpl
je 0x24f9
movl $0x30, %edi
callq 0x2140
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movb $0x1, 0x4(%rax)
movq %rbx, %rdi
callq 0x4720
movl %eax, 0x8(%r14)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x468c
movq %r14, %rdi
addq $0xc, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2110
cmpq %r13, %r15
je 0x24d2
movq %r15, %rdi
callq 0x2120
movw $0x68, 0x1a(%r14)
movl $0x63746546, 0x16(%r14) # imm = 0x63746546
movq $0x0, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x4724
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2508
callq 0x2120
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2534
jmp 0x2534
movq %rax, %r14
jmp 0x2546
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x254e
callq 0x2120
jmp 0x254e
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2546
callq 0x2120
movq %rbx, %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x21c0