LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/typecheck.c
// Function: TypeCheckFail_init
TypeCheckResult *TypeCheckFail_init(TypeErrorVector *errors) {
    TypeCheckResult *res = challoc(sizeof(TypeCheckResult));
    res->success = false;
    res->type    = NULL;
    res->errors  = errors;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x62f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/typecheck.c
// Function: TypeCheckResult_free
void TypeCheckResult_free(TypeCheckResult *result) {
    if(result->success) { Type_free(result->type); }
    else { TypeErrorVector_free(result->errors); }
    free(result);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x188e4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16220
jmp 0x188f1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x179c0
movq -0x8(%rbp), %rdi
callq 0x6030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/typecheck.c
// Function: check_Comm
TypeCheckResult *check_Comm(Comm *comm, TypeVector *symbol_table) {
    if(Comm_isWhile(comm)) {}
    else if(Comm_isAssign(comm)) {}
    else if(Comm_isReturn(comm)) {

    }
    else if(Comm_isComp(comm)) {
        TypeCheckResult *fst_res = check_Comm(Comp_fst(comm), symbol_table);
    }
    else { ERROR("Unrecognised Comm type"); }
    NOT_IMPLEMENTED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3ee0, %rsp           # imm = 0x3EE0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x18e41
jmp 0x18f4f
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x18e4f
jmp 0x18f4d
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x18e5d
jmp 0x18f4b
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x18e80
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x18e20
movq %rax, -0x20(%rbp)
jmp 0x18f49
jmp 0x18e82
leaq 0xb17b(%rip), %rdi      # 0x24004
leaq 0xc3aa(%rip), %rsi      # 0x2523a
movl $0xa8, %edx
leaq 0xc582(%rip), %rcx      # 0x2541e
movb $0x0, %al
callq 0x60f0
leaq 0xb182(%rip), %rdi      # 0x2402c
leaq 0xc578(%rip), %rsi      # 0x25429
movb $0x0, %al
callq 0x60f0
leaq -0x1f60(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f64(%rbp)
leaq -0x1f60(%rbp), %rdi
movl -0x1f64(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f70(%rbp)
leaq 0xb15c(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f74(%rbp)
movl -0x1f74(%rbp), %eax
cmpl -0x1f64(%rbp), %eax
jge 0x18f3f
movq -0x1f70(%rbp), %rax
movslq -0x1f74(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xb105(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f74(%rbp)
jmp 0x18f00
movl $0x1, %edi
callq 0x61a0
jmp 0x18f4b
jmp 0x18f4d
jmp 0x18f4f
jmp 0x18f51
leaq 0xb0ac(%rip), %rdi      # 0x24004
leaq 0xc2db(%rip), %rsi      # 0x2523a
movl $0xa9, %edx
leaq 0xc4b3(%rip), %rcx      # 0x2541e
movb $0x0, %al
callq 0x60f0
leaq 0xb0b3(%rip), %rdi      # 0x2402c
leaq 0xc47e(%rip), %rsi      # 0x253fe
movb $0x0, %al
callq 0x60f0
leaq -0x3ec0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x3ec4(%rbp)
leaq -0x3ec0(%rbp), %rdi
movl -0x3ec4(%rbp), %esi
callq 0x60a0
movq %rax, -0x3ed0(%rbp)
leaq 0xb08d(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x3ed4(%rbp)
movl -0x3ed4(%rbp), %eax
cmpl -0x3ec4(%rbp), %eax
jge 0x1900e
movq -0x3ed0(%rbp), %rax
movslq -0x3ed4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xb036(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x3ed4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3ed4(%rbp)
jmp 0x18fcf
movl $0x1, %edi
callq 0x61a0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/interpreter.c
// Function: InterpretResult_init
InterpretResult *InterpretResult_init(interpretResultType type, int result,
        bool returning, int line_no, int char_no) {

    InterpretResult *ir = challoc(sizeof(InterpretResult));
    ir->type      = type;
    ir->result    = result;
    ir->returning = returning;
    ir->line_no   = line_no;
    ir->char_no   = char_no;
    return ir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x14, %edi
callq 0x62f0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/interpreter.c
// Function: interpret_Prog
InterpretResult *interpret_Prog(Prog *prog, IntRefVector *args) {

    // Create a Call Expr to call main
    ExprVector *arg_exprs = ExprVector_init();
    int idx;
    for(idx = 0; idx < IntRefVector_size(args); idx++) {
        ExprVector_append(arg_exprs,
                Int_init(IntRef_value(IntRefVector_get(args, idx))));
    }
    Expr *main_call = Call_init(0, arg_exprs);

    // Run the call
    InterpretResult *result = interpret_Expr(prog, main_call, NULL);

    // Free the call
    Expr_free(main_call);

    // Return the result
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0xb740
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7e20
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x194bc
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x81e0
movl (%rax), %edi
callq 0xcd50
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xb890
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19472
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0xce10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x19500
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb6f0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/interpreter.c
// Function: interpret_Func
InterpretResult *interpret_Func(Prog *prog, Func *func, int *store) {

    // The store is created for us in the interpret_Expr() Call case. Run the
    // command with the store, check for errors, and return.

    InterpretResult *res = interpret_Comm(prog, Func_body(func), store);

    if(res->type == iSuccess && res->returning == false) {
        free(res);
        return InterpretFailEndWithoutReturn_init(Func_src_line_no(func),
                Func_src_char_no(func));
    }
    else {
        return res;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x199c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x199a2
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x199a2
movq -0x28(%rbp), %rdi
callq 0x6030
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x19420
movq %rax, -0x8(%rbp)
jmp 0x199aa
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode.c
// Function: ICodeOperation_init
ICodeOperation *ICodeOperation_init(Opcode opc, int arg1, int arg2) {
    ICodeOperation *op = challoc(sizeof(ICodeOperation));
    op->opc       = opc;
    op->arg1      = arg1;
    op->arg2      = arg2;
    return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0xc, %edi
callq 0x62f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode.c
// Function: reg_print
void reg_print(int reg) {
    if(reg < 0) {
        printf("Reg %d invalid.\n", reg);
        ERROR("Invalid Register");
    }
    else if(reg == STACK_POINTER) {
        printf("STACK_POINTER");
    }
    else if(reg == FRAME_POINTER) {
        printf("FRAME_POINTER");
    }
    else if(reg == RETURN_ADDRESS) {
        printf("RETURN_ADDRESS");
    }
    else if(reg == PROGRAM_COUNTER) {
        printf("PROGRAM_COUNTER");
    }
    else if(reg == ACCUMULATOR) {
        printf("ACCUMULATOR");
    }
    else if(reg == TEMPORARY) {
        printf("TEMPORARY");
    }
    else {
        printf("R%d", reg - 6);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x1a440
movl -0x4(%rbp), %esi
leaq 0xb200(%rip), %rdi      # 0x25572
movb $0x0, %al
callq 0x60f0
leaq 0x9c84(%rip), %rdi      # 0x24004
leaq 0xb10b(%rip), %rsi      # 0x25492
movl $0x63, %edx
leaq 0xb1f0(%rip), %rcx      # 0x25583
movb $0x0, %al
callq 0x60f0
leaq 0x9c8b(%rip), %rdi      # 0x2402c
leaq 0xb1e5(%rip), %rsi      # 0x2558d
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x9c65(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x1a436
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x9c0e(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x1a3f7
movl $0x1, %edi
callq 0x61a0
cmpl $0x0, -0x4(%rbp)
jne 0x1a459
leaq 0xb151(%rip), %rdi      # 0x2559e
movb $0x0, %al
callq 0x60f0
jmp 0x1a4e5
cmpl $0x1, -0x4(%rbp)
jne 0x1a46f
leaq 0xb146(%rip), %rdi      # 0x255ac
movb $0x0, %al
callq 0x60f0
jmp 0x1a4e3
cmpl $0x2, -0x4(%rbp)
jne 0x1a485
leaq 0xb13e(%rip), %rdi      # 0x255ba
movb $0x0, %al
callq 0x60f0
jmp 0x1a4e1
cmpl $0x3, -0x4(%rbp)
jne 0x1a49b
leaq 0xb137(%rip), %rdi      # 0x255c9
movb $0x0, %al
callq 0x60f0
jmp 0x1a4df
cmpl $0x4, -0x4(%rbp)
jne 0x1a4b1
leaq 0xb131(%rip), %rdi      # 0x255d9
movb $0x0, %al
callq 0x60f0
jmp 0x1a4dd
cmpl $0x5, -0x4(%rbp)
jne 0x1a4c7
leaq 0xb127(%rip), %rdi      # 0x255e5
movb $0x0, %al
callq 0x60f0
jmp 0x1a4db
movl -0x4(%rbp), %esi
subl $0x6, %esi
leaq 0xb11b(%rip), %rdi      # 0x255ef
movb $0x0, %al
callq 0x60f0
jmp 0x1a4dd
jmp 0x1a4df
jmp 0x1a4e1
jmp 0x1a4e3
jmp 0x1a4e5
jmp 0x1a4e7
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icodegen.c
// Function: icodegen_Prog
ICodeOperationVector *icodegen_Prog(Prog *prog, int *next_label) {

    // Allocate space for the map from function names to label names
    int *func_labels = challoc(sizeof(int) * Prog_num_funcs(prog));

    // Populate the map from function names to label names
    int idx;
    for(idx = 0; idx < Prog_num_funcs(prog); idx++) {
        func_labels[idx] = (*next_label)++;
    }

    BEGIN_CODE_GENERATION;

    // Make a call to main
    INSERT_OPERATION(JUMPLINK   , func_labels[0], 0                 );

    // Halt when the call returns
    INSERT_OPERATION(HALT       , 0             , 0                 );

    for(idx = 0; idx < Prog_num_funcs(prog); idx++) {
        INSERT_FUNC_CODE(Prog_func(prog, idx));
    }

    free(func_labels);

    RETURN_GENERATED_CODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9650
cltq
shlq $0x2, %rax
movl %eax, %edi
callq 0x62f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9650
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x1bb32
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1baf4
movb $0x0, %al
callq 0x1a4f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x8, %edi
xorl %edx, %edx
callq 0x19c90
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xb, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x19c90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9650
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1bbfb
jmp 0x1bba9
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x9860
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1bc10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1a7a0
movq -0x30(%rbp), %rdi
callq 0x1afa0
jmp 0x1bbf0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bb8c
movq -0x18(%rbp), %rdi
callq 0x6030
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icodegen.c
// Function: icodegen_Func
ICodeOperationVector *icodegen_Func(Prog *prog, Func *func, int *next_label,
        int *func_labels) {

    // Determine the label to use as the entry label for this function
    int func_label = func_labels[Func_name(func)];

    BEGIN_CODE_GENERATION;

    // Since the caller does all the work of a function call, all we include is
    // an entry label and code for the function body.
    INSERT_OPERATION(LABEL      , func_label    , 0                 );
    INSERT_COMM_CODE(Func_body(func));

    RETURN_GENERATED_CODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movb $0x0, %al
callq 0x1a4f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %esi
movl $0xa, %edi
xorl %edx, %edx
callq 0x19c90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1bcb0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a7a0
movq -0x38(%rbp), %rdi
callq 0x1afa0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode_interpreter.c
// Function: ICodeOperationVector_execute
int ICodeOperationVector_execute(ICodeOperationVector *code,
        IntRefVector *initial_stack) {

    ICodeInterpreterState *state = ICodeInterpreterState_init(code,
            initial_stack);

    ICodeInterpreterState_run(state);

    int result = ICodeInterpreterState_result(state);

    ICodeInterpreterState_free(state);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cf40
movq -0x18(%rbp), %rdi
callq 0x1cf80
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d0a0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode_interpreter.c
// Function: ICodeInterpreterState_run
void ICodeInterpreterState_run(ICodeInterpreterState *state) {

    // Until we reach a halt instruction...
    while((ICodeOperationVector_get(state->code,
            (state->registers)[PROGRAM_COUNTER])->opc) != HALT) {

        // Step through the next instruction.
        ICodeInterpreterState_step(state);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %esi
callq 0x1a900
cmpl $0xb, (%rax)
je 0x1cf73
movq -0x8(%rbp), %rdi
callq 0x1d2f0
jmp 0x1cf4c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode_interpreter.c
// Function: ICodeInterpreterState_result
int ICodeInterpreterState_result(ICodeInterpreterState *state) {

    if((ICodeOperationVector_get(state->code,
            (state->registers)[PROGRAM_COUNTER])->opc) == HALT) {

        return (state->registers)[ACCUMULATOR];
    }
    else {
        ERROR("Tried to retreive the result of a non-halted execution");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %esi
callq 0x1a900
cmpl $0xb, (%rax)
jne 0x1cfbe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d087
jmp 0x1cfc0
leaq 0x703d(%rip), %rdi      # 0x24004
leaq 0x8748(%rip), %rsi      # 0x25716
movl $0xb3, %edx
leaq 0x880e(%rip), %rcx      # 0x257e8
movb $0x0, %al
callq 0x60f0
leaq 0x7044(%rip), %rdi      # 0x2402c
leaq 0x8816(%rip), %rsi      # 0x25805
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x701e(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x1d07d
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6fc7(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x1d03e
movl $0x1, %edi
callq 0x61a0
movl -0x4(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode_interpreter.c
// Function: ICodeInterpreterState_free
void ICodeInterpreterState_free(ICodeInterpreterState *state) {
    free(state->stack);
    free(state->registers);
    free(state->labels);
    free(state);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rdi
callq 0x6030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/icode_interpreter.c
// Function: ICodeInterpreterState_check_stack_bounds
void ICodeInterpreterState_check_stack_bounds(int stack_index) {
    if(stack_index >= ICodeInterpreterState_STACK_SIZE) {
        ERROR("Stack overflow");
    }
    else if(stack_index < 0) {
        ERROR("Stack underflow");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3ed0, %rsp           # imm = 0x3ED0
movl %edi, -0x4(%rbp)
cmpl $0x186a0, -0x4(%rbp)    # imm = 0x186A0
jl 0x1d204
jmp 0x1d13d
leaq 0x6ec0(%rip), %rdi      # 0x24004
leaq 0x85cb(%rip), %rsi      # 0x25716
movl $0x95, %edx
leaq 0x8649(%rip), %rcx      # 0x257a0
movb $0x0, %al
callq 0x60f0
leaq 0x6ec7(%rip), %rdi      # 0x2402c
leaq 0x865d(%rip), %rsi      # 0x257c9
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x6ea1(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x1d1fa
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6e4a(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x1d1bb
movl $0x1, %edi
callq 0x61a0
cmpl $0x0, -0x4(%rbp)
jge 0x1d2d7
jmp 0x1d210
leaq 0x6ded(%rip), %rdi      # 0x24004
leaq 0x84f8(%rip), %rsi      # 0x25716
movl $0x98, %edx
leaq 0x8576(%rip), %rcx      # 0x257a0
movb $0x0, %al
callq 0x60f0
leaq 0x6df4(%rip), %rdi      # 0x2402c
leaq 0x8599(%rip), %rsi      # 0x257d8
movb $0x0, %al
callq 0x60f0
leaq -0x3eb0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x3eb4(%rbp)
leaq -0x3eb0(%rbp), %rdi
movl -0x3eb4(%rbp), %esi
callq 0x60a0
movq %rax, -0x3ec0(%rbp)
leaq 0x6dce(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x3ec4(%rbp)
movl -0x3ec4(%rbp), %eax
cmpl -0x3eb4(%rbp), %eax
jge 0x1d2cd
movq -0x3ec0(%rbp), %rax
movslq -0x3ec4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6d77(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x3ec4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3ec4(%rbp)
jmp 0x1d28e
movl $0x1, %edi
callq 0x61a0
jmp 0x1d2d9
addq $0x3ed0, %rsp           # imm = 0x3ED0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/vmcodegen.c
// Function: VMCodeGen
int *VMCodeGen(ICodeOperationVector *code) {

    int *out = challoc(sizeof(int) * VMCode_instruction_size *
            ICodeOperationVector_size(code));

    int *out_ptr = out;

    int icode_idx;
    for(icode_idx = 0; icode_idx < ICodeOperationVector_size(code);
            icode_idx++) {

        ICodeOperation *op = ICodeOperationVector_get(code, icode_idx);

        memcpy(out_ptr, op, sizeof(ICodeOperation));

        out_ptr += sizeof(ICodeOperation);
    }

    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a540
cltq
imulq $0x30, %rax, %rax
movl %eax, %edi
callq 0x62f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a540
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1d758
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1a900
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d705
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/vmcodegen.c
// Function: VMCode_print
void VMCode_print(int *vmcode, int num_instructions) {
    int idx = 0;
    while(idx < num_instructions) {
        ICodeOperation_print(
                (ICodeOperation *) (vmcode + (idx * VMCode_instruction_size)));
        idx++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1d7b1
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0xc, %rax, %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x19f90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d786
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/vmcode_interpreter.c
// Function: VMCode_execute
int VMCode_execute(ICodeOperationVector *code, IntRefVector *initial_stack) {
    VMCodeInterpreterState* vmstate =
            VMCodeInterpreterState_init(code, initial_stack);
    VMCodeInterpreterState_run(vmstate);
    int result = (vmstate->registers)[ACCUMULATOR];
    VMCodeInterpreterState_free(vmstate);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d810
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d8b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ddf0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/vmcode_interpreter.c
// Function: VMCodeInterpreterState_init
VMCodeInterpreterState *VMCodeInterpreterState_init(
        ICodeOperationVector *code, IntRefVector *initial_stack) {

    ICodeInterpreterState  *icode_state  =
            ICodeInterpreterState_init(code, initial_stack);

    VMCodeInterpreterState *vmcode_state =
            challoc(sizeof(VMCodeInterpreterState));

    vmcode_state->code      = VMCodeGen(code);
    vmcode_state->stack     = icode_state->stack;
    vmcode_state->registers = icode_state->registers;
    vmcode_state->labels    = icode_state->labels;
    vmcode_state->min_label = icode_state->min_label;
    free(icode_state);
    return vmcode_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca50
movq %rax, -0x18(%rbp)
movl $0x28, %edi
callq 0x62f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d6d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x6030
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/vmcode_interpreter.c
// Function: VMCodeInterpreterState_free
void VMCodeInterpreterState_free(VMCodeInterpreterState *state) {
    free(state->code);
    free(state->stack);
    free(state->registers);
    free(state->labels);
    free(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6030
movq -0x8(%rbp), %rdi
callq 0x6030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/ncode.c
// Function: allocate_executable
byte *allocate_executable(byte *memory, size_t size) {

	void *exec_mem = mmap(NULL, size,
		PROT_WRITE | PROT_EXEC,	MAP_ANON | MAP_PRIVATE, -1, 0);

	memcpy(exec_mem, memory, size);

    return (byte *) exec_mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x6, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x60e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6130
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/ncodegen.c
// Function: NCodeLinkable_init
NCodeLinkable *NCodeLinkable_init(byte *ncode_buf, int ncode_size,
        LinkTargetVector *link_targets, IntRefVector *label_map) {
    NCodeLinkable *ncl = challoc(sizeof(NCodeLinkable));
    ncl->ncode_buf     = ncode_buf;
    ncl->ncode_size    = ncode_size;
    ncl->link_targets  = link_targets;
    ncl->label_map     = label_map;
    return ncl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x62f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/ncodegen.c
// Function: LinkTarget_init
DEFINE_VECTORABLE(LinkTarget)

LinkTarget *LinkTarget_init(int jump_address, int label_no) {
    LinkTarget *link   = challoc(sizeof(LinkTarget));
    link->jump_address = jump_address;
    link->label_no     = label_no;
    return link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x8, %edi
callq 0x62f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: TestProgram_init
DEFINE_VECTORABLE(TestProgram)

TestProgram *TestProgram_init(char *prog_str, int arity,
        int (*c_version)(IntRefVector *)) {

    TestProgram *tp = challoc(sizeof(TestProgram));
    tp->prog_str    = prog_str;
    tp->arity       = arity;
    tp->c_version   = c_version;
    return tp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x62f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp1_main
int tp1_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp1_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x89d2(%rip), %eax      # 0x2b1a0
je 0x2289d
jmp 0x227d6
leaq 0x1827(%rip), %rdi      # 0x24004
leaq 0x328e(%rip), %rsi      # 0x25a72
movl $0x33, %edx
leaq 0x3425(%rip), %rcx      # 0x25c15
movb $0x0, %al
callq 0x60f0
leaq 0x182e(%rip), %rdi      # 0x2402c
leaq 0x33c5(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x1808(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x22893
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x17b1(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22854
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movl -0x1f68(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp2_main
int tp2_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp2_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    return a + b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x88d2(%rip), %eax      # 0x2b1b0
je 0x229ad
jmp 0x228e6
leaq 0x1717(%rip), %rdi      # 0x24004
leaq 0x317e(%rip), %rsi      # 0x25a72
movl $0x3e, %edx
leaq 0x333a(%rip), %rcx      # 0x25c3a
movb $0x0, %al
callq 0x60f0
leaq 0x171e(%rip), %rdi      # 0x2402c
leaq 0x32b5(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x16f8(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x229a3
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x16a1(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22964
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f6c(%rbp)
movl -0x1f68(%rbp), %eax
addl -0x1f6c(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp3_main
int tp3_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp3_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    return a - b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x87b2(%rip), %eax      # 0x2b1c0
je 0x22add
jmp 0x22a16
leaq 0x15e7(%rip), %rdi      # 0x24004
leaq 0x304e(%rip), %rsi      # 0x25a72
movl $0x4b, %edx
leaq 0x322f(%rip), %rcx      # 0x25c5f
movb $0x0, %al
callq 0x60f0
leaq 0x15ee(%rip), %rdi      # 0x2402c
leaq 0x3185(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x15c8(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x22ad3
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1571(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22a94
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f6c(%rbp)
movl -0x1f68(%rbp), %eax
subl -0x1f6c(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp4_main
int tp4_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp4_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    a = a + 1;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x8692(%rip), %eax      # 0x2b1d0
je 0x22c0d
jmp 0x22b46
leaq 0x14b7(%rip), %rdi      # 0x24004
leaq 0x2f1e(%rip), %rsi      # 0x25a72
movl $0x58, %edx
leaq 0x3129(%rip), %rcx      # 0x25c89
movb $0x0, %al
callq 0x60f0
leaq 0x14be(%rip), %rdi      # 0x2402c
leaq 0x3055(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x1498(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x22c03
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1441(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22bc4
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movl -0x1f68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f68(%rbp)
movl -0x1f68(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp5_main
int tp5_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp5_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    int c = a;
    while((b - 1) > 0) {
        b = b - 1;
        a = a + c;
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x8582(%rip), %eax      # 0x2b1e0
je 0x22d2d
jmp 0x22c66
leaq 0x1397(%rip), %rdi      # 0x24004
leaq 0x2dfe(%rip), %rsi      # 0x25a72
movl $0x6c, %edx
leaq 0x30e3(%rip), %rcx      # 0x25d63
movb $0x0, %al
callq 0x60f0
leaq 0x139e(%rip), %rdi      # 0x2402c
leaq 0x2f35(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x1378(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x22d23
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1321(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22ce4
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f6c(%rbp)
movl -0x1f68(%rbp), %eax
movl %eax, -0x1f70(%rbp)
movl -0x1f6c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x22d93
movl -0x1f6c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1f6c(%rbp)
movl -0x1f68(%rbp), %eax
addl -0x1f70(%rbp), %eax
movl %eax, -0x1f68(%rbp)
jmp 0x22d62
movl -0x1f68(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: tp6_main
int tp6_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp6_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    return tp6_foo(a) + a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f70, %rsp           # imm = 0x1F70
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e20
cmpl 0x8412(%rip), %eax      # 0x2b1f0
je 0x22ead
jmp 0x22de6
leaq 0x1217(%rip), %rdi      # 0x24004
leaq 0x2c7e(%rip), %rsi      # 0x25a72
movl $0x85, %edx
leaq 0x3009(%rip), %rcx      # 0x25e09
movb $0x0, %al
callq 0x60f0
leaq 0x121e(%rip), %rdi      # 0x2402c
leaq 0x2db5(%rip), %rsi      # 0x25bca
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0x11f8(%rip), %rdi      # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x22ea3
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x11a1(%rip), %rdi      # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x22e64
movl $0x1, %edi
callq 0x61a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movl (%rax), %eax
movl %eax, -0x1f68(%rbp)
movl -0x1f68(%rbp), %edi
callq 0x22db0
addl -0x1f68(%rbp), %eax
addq $0x1f70, %rsp           # imm = 0x1F70
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alexj136[P]minijit/src/testing_programs.c
// Function: get_test_program
TestProgram *get_test_program(int number) {
    if(!test_program_vector) { ERROR("Testing programs not prepared"); }

    if(number >= TestProgramVector_size(test_program_vector)) {
        ERROR("test program at given index does not exist");
    }
    else { return TestProgramVector_get(test_program_vector, number); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3ed0, %rsp           # imm = 0x3ED0
movl %edi, -0xc(%rbp)
cmpq $0x0, 0x814a(%rip)      # 0x2b2c0
jne 0x23245
jmp 0x2317e
leaq 0xe7f(%rip), %rdi       # 0x24004
leaq 0x28e6(%rip), %rsi      # 0x25a72
movl $0xa6, %edx
leaq 0x2cb5(%rip), %rcx      # 0x25e4d
movb $0x0, %al
callq 0x60f0
leaq 0xe86(%rip), %rdi       # 0x2402c
leaq 0x2cb1(%rip), %rsi      # 0x25e5e
movb $0x0, %al
callq 0x60f0
leaq -0x1f50(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x1f54(%rbp)
leaq -0x1f50(%rbp), %rdi
movl -0x1f54(%rbp), %esi
callq 0x60a0
movq %rax, -0x1f60(%rbp)
leaq 0xe60(%rip), %rdi       # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x1f64(%rbp)
movl -0x1f64(%rbp), %eax
cmpl -0x1f54(%rbp), %eax
jge 0x2323b
movq -0x1f60(%rbp), %rax
movslq -0x1f64(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xe09(%rip), %rdi       # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x1f64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f64(%rbp)
jmp 0x231fc
movl $0x1, %edi
callq 0x61a0
movl -0xc(%rbp), %eax
movl %eax, -0x3ec8(%rbp)
movq 0x806b(%rip), %rdi      # 0x2b2c0
callq 0x20e80
movl %eax, %ecx
movl -0x3ec8(%rbp), %eax
cmpl %ecx, %eax
jl 0x23333
jmp 0x2326c
leaq 0xd91(%rip), %rdi       # 0x24004
leaq 0x27f8(%rip), %rsi      # 0x25a72
movl $0xa9, %edx
leaq 0x2bc7(%rip), %rcx      # 0x25e4d
movb $0x0, %al
callq 0x60f0
leaq 0xd98(%rip), %rdi       # 0x2402c
leaq 0x2be1(%rip), %rsi      # 0x25e7c
movb $0x0, %al
callq 0x60f0
leaq -0x3eb0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60d0
movl %eax, -0x3eb4(%rbp)
leaq -0x3eb0(%rbp), %rdi
movl -0x3eb4(%rbp), %esi
callq 0x60a0
movq %rax, -0x3ec0(%rbp)
leaq 0xd72(%rip), %rdi       # 0x2404b
movb $0x0, %al
callq 0x60f0
movl $0x0, -0x3ec4(%rbp)
movl -0x3ec4(%rbp), %eax
cmpl -0x3eb4(%rbp), %eax
jge 0x23329
movq -0x3ec0(%rbp), %rax
movslq -0x3ec4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd1b(%rip), %rdi       # 0x2402c
movb $0x0, %al
callq 0x60f0
movl -0x3ec4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3ec4(%rbp)
jmp 0x232ea
movl $0x1, %edi
callq 0x61a0
movq 0x7f86(%rip), %rdi      # 0x2b2c0
movl -0xc(%rbp), %esi
callq 0x21240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x3ed0, %rsp           # imm = 0x3ED0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/setuidgid/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * opt_username_groupname;

	WARNP_INIT;

	/* Print usage, if necessary. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_setuid "
		    "{USERNAME | :GROUPNAME | USERNAME:GROUPNAME}\n");
		goto err0;
	}
	opt_username_groupname = argv[1];

	/* Change username (and groupname). */
	if (setuidgid(opt_username_groupname, SETUIDGID_SGROUP_LEAVE_WARN)) {
		if (errno == EPERM) {
			warn0("Insufficient permissions to change your user"
			    " or group(s).");
			goto nopermission;
		}
		goto err0;
	}

	/* Success! */
	return (0);

nopermission:
	/* Failure! */
	exit(EX_NOPERM);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x131c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1d50
jmp 0x131e
cmpl $0x2, -0x8(%rbp)
je 0x133e
movq 0x3ccd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1ccf(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1100
jmp 0x1398
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x13b0
cmpl $0x0, %eax
je 0x1386
callq 0x1070
cmpl $0x1, (%rax)
jne 0x1384
jmp 0x1369
leaq 0x1cd5(%rip), %rdi      # 0x3045
movb $0x0, %al
callq 0x2060
callq 0x1070
movl $0x0, (%rax)
jmp 0x138e
jmp 0x1398
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
movl $0x4d, %edi
callq 0x11b0
movl $0x1, %edi
callq 0x11b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/setuidgid.c
// Function: check_supplementary_groups_none
static int
check_supplementary_groups_none(void)
{
	gid_t grouplist[1];
	int ngroups;

	/* Find number of groups. */
	if ((ngroups = getgroups(0, NULL)) < 0) {
		warnp("getgroups()");
		goto err0;
	}

	/* Check group membership. */
	if (ngroups > 1)
		/* Definitely failed. */
		goto err0;
	if (ngroups == 1) {
		/*
		 * POSIX allows getgroups() to return the effective group ID,
		 * so if we're in exactly one group, we need to check that GID.
		 */
		if (getgroups(1, grouplist) != 1) {
			warnp("getgroups()");
			goto err0;
		}
		/* POSIX: getegid() shall not modify errno. */
		if (grouplist[0] != getegid())
			goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1130
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x1794
jmp 0x175d
callq 0x1070
cmpl $0x0, (%rax)
je 0x1782
leaq 0x1a0c(%rip), %rdi      # 0x317a
movb $0x0, %al
callq 0x1e10
callq 0x1070
movl $0x0, (%rax)
jmp 0x1790
leaq 0x19f1(%rip), %rdi      # 0x317a
movb $0x0, %al
callq 0x2060
jmp 0x1792
jmp 0x180f
cmpl $0x1, -0xc(%rbp)
jle 0x179c
jmp 0x180f
cmpl $0x1, -0xc(%rbp)
jne 0x1806
leaq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x1130
cmpl $0x1, %eax
je 0x17ee
jmp 0x17b7
callq 0x1070
cmpl $0x0, (%rax)
je 0x17dc
leaq 0x19b2(%rip), %rdi      # 0x317a
movb $0x0, %al
callq 0x1e10
callq 0x1070
movl $0x0, (%rax)
jmp 0x17ea
leaq 0x1997(%rip), %rdi      # 0x317a
movb $0x0, %al
callq 0x2060
jmp 0x17ec
jmp 0x180f
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x1160
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
je 0x1804
jmp 0x180f
jmp 0x1806
movl $0x0, -0x4(%rbp)
jmp 0x1816
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop