LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
pushq $0xc
popq %rdi
callq 0x62ec
movl %r15d, (%rax)
movl %r14d, 0x4(%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/alexj136[P]minijit/src/icode.c
// Function: ICodeOperation_eq
bool ICodeOperation_eq(ICodeOperation *op1, ICodeOperation *op2) {
    // Null checks are essentially to supress the unused parameter warning
    if(!op1) { ERROR("Null Operation"); }
    if(!op2) { ERROR("Null Operation"); }
    ERROR("Equality not defined for Operation");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
testq %rdi, %rdi
jne 0x13102
leaq 0x6f8b(%rip), %rdi      # 0x1a004
leaq 0x846c(%rip), %rsi      # 0x1b4ec
leaq 0x8471(%rip), %rcx      # 0x1b4f8
xorl %r12d, %r12d
pushq $0x14
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x6f91(%rip), %rbx      # 0x1a02c
leaq 0x8468(%rip), %rsi      # 0x1b50a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x713f(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x13220
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x130e6
leaq 0x6efb(%rip), %rdi      # 0x1a004
testq %rsi, %rsi
jne 0x1319b
leaq 0x83d3(%rip), %rsi      # 0x1b4ec
leaq 0x83d8(%rip), %rcx      # 0x1b4f8
xorl %r12d, %r12d
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x6ef8(%rip), %rbx      # 0x1a02c
leaq 0x83cf(%rip), %rsi      # 0x1b50a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x70a6(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x13220
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x1317f
leaq 0x834a(%rip), %rsi      # 0x1b4ec
leaq 0x834f(%rip), %rcx      # 0x1b4f8
xorl %r12d, %r12d
pushq $0x16
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x6e6f(%rip), %rbx      # 0x1a02c
leaq 0x8355(%rip), %rsi      # 0x1b519
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x701d(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x13220
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x13208
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %esi
testl %edi, %edi
js 0x13446
cmpl $0x5, %esi
ja 0x13435
movl %esi, %eax
leaq 0x80e3(%rip), %rcx      # 0x1b4d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x81f1(%rip), %rdi      # 0x1b5f2
jmp 0x1342e
leaq 0x8223(%rip), %rdi      # 0x1b62d
jmp 0x1342e
leaq 0x81fb(%rip), %rdi      # 0x1b60e
jmp 0x1342e
leaq 0x8201(%rip), %rdi      # 0x1b61d
jmp 0x1342e
leaq 0x81db(%rip), %rdi      # 0x1b600
jmp 0x1342e
leaq 0x820b(%rip), %rdi      # 0x1b639
xorl %eax, %eax
jmp 0x6100
addl $-0x6, %esi
leaq 0x8204(%rip), %rdi      # 0x1b643
xorl %eax, %eax
jmp 0x6100
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
leaq 0x8167(%rip), %rdi      # 0x1b5c6
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x6100
leaq 0x6b94(%rip), %rdi      # 0x1a004
leaq 0x8075(%rip), %rsi      # 0x1b4ec
leaq 0x8159(%rip), %rcx      # 0x1b5d7
pushq $0x63
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x6b9d(%rip), %rbx      # 0x1a02c
leaq 0x814b(%rip), %rsi      # 0x1b5e1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x6d4b(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x134f2
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x134da
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x8558
leal (,%rax,4), %edi
callq 0x62ec
movq %rax, %r15
xorl %r12d, %r12d
movq (%r14), %rdi
callq 0x8558
cltq
cmpq %rax, %r12
jge 0x143e9
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
movl %eax, (%r15,%r12,4)
incq %r12
jmp 0x143ca
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x134fa
movq %rax, %r12
movl (%r15), %esi
pushq $0x8
popq %rdi
xorl %edx, %edx
callq 0x13028
movq %r12, %rdi
movq %rax, %rsi
callq 0x135dc
pushq $0xb
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13028
movq %r12, -0x30(%rbp)
movq %r12, %rdi
movq %rax, %rsi
callq 0x135dc
movq (%r14), %rdi
callq 0x8558
cmpl %eax, %r13d
jge 0x1446e
movq (%r14), %rdi
movl %r13d, %esi
callq 0x86d9
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x14489
movq %rax, %r12
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x136c9
movq %r12, %rdi
callq 0x13c48
incl %r13d
jmp 0x14429
movq %r15, %rdi
callq 0x6030
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r13
movslq (%rsi), %rax
movl (%rcx,%rax,4), %r15d
xorl %eax, %eax
callq 0x134fa
movq %rax, %rbx
pushq $0xa
popq %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x13028
movq %rbx, %rdi
movq %rax, %rsi
callq 0x135dc
movq 0x10(%r12), %rsi
movq %r13, %rdi
movq -0x30(%rbp), %rdx
movq %r14, %rcx
callq 0x14509
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x136c9
movq %r14, %rdi
callq 0x13c48
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
callq 0x14d42
movq %rax, %rbx
movq %rax, %rdi
callq 0x14ff5
movq %rbx, %rdi
callq 0x15023
movl %eax, %r14d
movq %rbx, %rdi
callq 0x150f9
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
callq 0x137b2
cmpl $0xb, (%rax)
je 0x1501c
movq %rbx, %rdi
callq 0x1529c
jmp 0x14ffe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
callq 0x137b2
cmpl $0xb, (%rax)
jne 0x15063
movq 0x10(%rbx), %rax
movl 0x10(%rax), %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f9a(%rip), %rdi      # 0x1a004
leaq 0x6783(%rip), %rsi      # 0x1b7f4
leaq 0x684e(%rip), %rcx      # 0x1b8c6
xorl %r12d, %r12d
movl $0xb3, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x4f9e(%rip), %rbx      # 0x1a02c
leaq 0x684e(%rip), %rsi      # 0x1b8e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x514c(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x150f1
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x150d9
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
cmpl $0x186a0, %edi          # imm = 0x186A0
jge 0x15174
testl %edi, %edi
js 0x15206
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e89(%rip), %rdi      # 0x1a004
leaq 0x6672(%rip), %rsi      # 0x1b7f4
leaq 0x66f5(%rip), %rcx      # 0x1b87e
xorl %r12d, %r12d
movl $0x95, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x4e8d(%rip), %rbx      # 0x1a02c
leaq 0x6701(%rip), %rsi      # 0x1b8a7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x503b(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x15294
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x151ea
leaq 0x4df7(%rip), %rdi      # 0x1a004
leaq 0x65e0(%rip), %rsi      # 0x1b7f4
leaq 0x6663(%rip), %rcx      # 0x1b87e
xorl %r12d, %r12d
movl $0x98, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x4dfb(%rip), %rbx      # 0x1a02c
leaq 0x667e(%rip), %rsi      # 0x1b8b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x4fa9(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x15294
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x1527c
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1352e
imull $0x30, %eax, %edi
callq 0x62ec
movq %rax, %r14
xorl %r15d, %r15d
movq %rax, %r12
movq %rbx, %rdi
callq 0x1352e
cmpl %eax, %r15d
jge 0x154a8
movq %rbx, %rdi
movl %r15d, %esi
callq 0x137b2
movq (%rax), %rcx
movq %rcx, (%r12)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r12)
addq $0x30, %r12
incl %r15d
jmp 0x15478
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
cmovgl %esi, %r14d
subq $0x1, %r14
jb 0x154db
movq %rbx, %rdi
callq 0x13232
addq $0x30, %rbx
jmp 0x154c7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
callq 0x1550f
movq %rax, %rbx
movq %rax, %rdi
callq 0x15570
movq 0x10(%rbx), %rax
movl 0x10(%rax), %r14d
movq %rbx, %rdi
callq 0x15709
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x14d42
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x62ec
movq %rax, %r15
movq %rbx, %rdi
callq 0x15454
movq %rax, (%r15)
movq 0x8(%r14), %rax
movq %rax, 0x8(%r15)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movq 0x18(%r14), %rax
movq %rax, 0x18(%r15)
movl 0x20(%r14), %eax
movl %eax, 0x20(%r15)
movq %r14, %rdi
callq 0x6030
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x62ec
movq %r12, (%rax)
movl %r15d, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/alexj136[P]minijit/src/ncodegen.c
// Function: LinkTargetVector_insert
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
testq %rdi, %rdi
je 0x16a7a
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r12d
testl %r14d, %r14d
js 0x1695a
movq %rbx, %rdi
callq 0x1646f
cmpl %r12d, %eax
jl 0x169ea
movl (%rbx), %eax
cmpq %rax, %r12
je 0x16940
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rcx
movq %r15, (%rax,%r12,8)
incq %r12
movq %rcx, %r15
jmp 0x1690f
movq %rbx, %rdi
movq %r15, %rsi
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1651d
leaq 0x36a3(%rip), %rdi      # 0x1a004
leaq 0x514c(%rip), %rsi      # 0x1bab4
leaq 0x519e(%rip), %rcx      # 0x1bb0d
xorl %r12d, %r12d
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x36a9(%rip), %rbx      # 0x1a02c
leaq 0x3756(%rip), %rsi      # 0x1a0e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x3857(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x16b06
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x169ce
leaq 0x3613(%rip), %rdi      # 0x1a004
leaq 0x50bc(%rip), %rsi      # 0x1bab4
leaq 0x510e(%rip), %rcx      # 0x1bb0d
xorl %r12d, %r12d
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x3619(%rip), %rbx      # 0x1a02c
leaq 0x36d6(%rip), %rsi      # 0x1a0f0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x37c7(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x16b06
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x16a5e
leaq 0x3583(%rip), %rdi      # 0x1a004
leaq 0x502c(%rip), %rsi      # 0x1bab4
leaq 0x507e(%rip), %rcx      # 0x1bb0d
xorl %r12d, %r12d
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x3589(%rip), %rbx      # 0x1a02c
leaq 0x35f0(%rip), %rsi      # 0x1a09a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x3737(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x16b06
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x16aee
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/alexj136[P]minijit/src/testing_programs.c
// Function: TestProgramVector_insert
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
testq %rdi, %rdi
je 0x17c9f
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r12d
testl %r14d, %r14d
js 0x17b7f
movq %rbx, %rdi
callq 0x17694
cmpl %r12d, %eax
jl 0x17c0f
movl (%rbx), %eax
cmpq %rax, %r12
je 0x17b65
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rcx
movq %r15, (%rax,%r12,8)
incq %r12
movq %rcx, %r15
jmp 0x17b34
movq %rbx, %rdi
movq %r15, %rsi
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17742
leaq 0x247e(%rip), %rdi      # 0x1a004
leaq 0x4024(%rip), %rsi      # 0x1bbb1
leaq 0x4081(%rip), %rcx      # 0x1bc15
xorl %r12d, %r12d
pushq $0x7
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x2484(%rip), %rbx      # 0x1a02c
leaq 0x2531(%rip), %rsi      # 0x1a0e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x2632(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x17d2b
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x17bf3
leaq 0x23ee(%rip), %rdi      # 0x1a004
leaq 0x3f94(%rip), %rsi      # 0x1bbb1
leaq 0x3ff1(%rip), %rcx      # 0x1bc15
xorl %r12d, %r12d
pushq $0x7
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x23f4(%rip), %rbx      # 0x1a02c
leaq 0x24b1(%rip), %rsi      # 0x1a0f0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x25a2(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x17d2b
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x17c83
leaq 0x235e(%rip), %rdi      # 0x1a004
leaq 0x3f04(%rip), %rsi      # 0x1bbb1
leaq 0x3f61(%rip), %rcx      # 0x1bc15
xorl %r12d, %r12d
pushq $0x7
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x2364(%rip), %rbx      # 0x1a02c
leaq 0x23cb(%rip), %rsi      # 0x1a09a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x2512(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x17d2b
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x17d13
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x99e4(%rip), %eax      # 0x221a0
jne 0x187da
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1823(%rip), %rdi      # 0x1a004
leaq 0x33c9(%rip), %rsi      # 0x1bbb1
leaq 0x3565(%rip), %rcx      # 0x1bd54
xorl %r12d, %r12d
pushq $0x33
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x1829(%rip), %rbx      # 0x1a02c
leaq 0x34ff(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x19d7(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x18866
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x1884e
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x9922(%rip), %eax      # 0x221b0
jne 0x188be
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x77bb
addl (%rax), %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x173f(%rip), %rdi      # 0x1a004
leaq 0x32e5(%rip), %rsi      # 0x1bbb1
leaq 0x34a6(%rip), %rcx      # 0x1bd79
xorl %r12d, %r12d
pushq $0x3e
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x1745(%rip), %rbx      # 0x1a02c
leaq 0x341b(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x18f3(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x1894a
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18932
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x984e(%rip), %eax      # 0x221c0
jne 0x189a2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x77bb
subl (%rax), %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x165b(%rip), %rdi      # 0x1a004
leaq 0x3201(%rip), %rsi      # 0x1bbb1
leaq 0x33e7(%rip), %rcx      # 0x1bd9e
xorl %r12d, %r12d
pushq $0x4b
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x1661(%rip), %rbx      # 0x1a02c
leaq 0x3337(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x180f(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x18a2e
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18a16
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x977a(%rip), %eax      # 0x221d0
jne 0x18a76
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %eax
incl %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1587(%rip), %rdi      # 0x1a004
leaq 0x312d(%rip), %rsi      # 0x1bbb1
leaq 0x333d(%rip), %rcx      # 0x1bdc8
xorl %r12d, %r12d
pushq $0x58
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x158d(%rip), %rbx      # 0x1a02c
leaq 0x3263(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x173b(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x18b02
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18aea
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x96b6(%rip), %eax      # 0x221e0
jne 0x18b68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %r15d
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x77bb
movl (%rax), %eax
cmpl $0x2, %eax
cmovgel %eax, %r14d
imull %r15d, %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1495(%rip), %rdi      # 0x1a004
leaq 0x303b(%rip), %rsi      # 0x1bbb1
leaq 0x3325(%rip), %rcx      # 0x1bea2
xorl %r12d, %r12d
pushq $0x6c
popq %rdx
xorl %eax, %eax
callq 0x6100
leaq 0x149b(%rip), %rbx      # 0x1a02c
leaq 0x3171(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x1649(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x18bf4
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18bdc
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x7537
cmpl 0x95cb(%rip), %eax      # 0x221f0
jne 0x18c4a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x77bb
movl (%rax), %eax
leal 0xa(,%rax,2), %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13b3(%rip), %rdi      # 0x1a004
leaq 0x2f59(%rip), %rsi      # 0x1bbb1
leaq 0x32e9(%rip), %rcx      # 0x1bf48
xorl %r12d, %r12d
movl $0x85, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x13b7(%rip), %rbx      # 0x1a02c
leaq 0x308d(%rip), %rsi      # 0x1bd09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x1565(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x18cd8
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18cc0
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movl %edi, %esi
movq 0x93cb(%rip), %rdi      # 0x222c0
testq %rdi, %rdi
je 0x18f16
cmpl %esi, (%rdi)
jle 0x18fa8
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17918
leaq 0x10e7(%rip), %rdi      # 0x1a004
leaq 0x2c8d(%rip), %rsi      # 0x1bbb1
leaq 0x3061(%rip), %rcx      # 0x1bf8c
xorl %r12d, %r12d
movl $0xa6, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x10eb(%rip), %rbx      # 0x1a02c
leaq 0x3055(%rip), %rsi      # 0x1bf9d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x1299(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x19036
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x18f8c
leaq 0x1055(%rip), %rdi      # 0x1a004
leaq 0x2bfb(%rip), %rsi      # 0x1bbb1
leaq 0x2fcf(%rip), %rcx      # 0x1bf8c
xorl %r12d, %r12d
movl $0xa9, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1059(%rip), %rbx      # 0x1a02c
leaq 0x2fe1(%rip), %rsi      # 0x1bfbb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %r15
movq %r15, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %r15
leaq 0x1207(%rip), %rdi      # 0x1a216
callq 0x6070
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x19036
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
jmp 0x1901e
pushq $0x1
popq %rdi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1311
callq 0x17a0
cmpl $0x2, %ebp
jne 0x132f
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1378
testl %eax, %eax
jne 0x1353
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2cc2(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xcc4(%rip), %rdi       # 0x2004
pushq $0x40
popq %rsi
pushq $0x1
popq %rdx
callq 0x11c0
pushq $0x1
popq %rdi
callq 0x11b0
callq 0x1060
cmpl $0x1, (%rax)
jne 0x134b
movq %rax, %rbx
leaq 0xcde(%rip), %rdi       # 0x2045
xorl %eax, %eax
callq 0x19ac
andl $0x0, (%rbx)
pushq $0x4d
jmp 0x134d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: sort_main
static void sort_main(libforks_ServerConn conn, int socket_fd) {
  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  assert(dup2(socket_fd, STDIN_FILENO) != -1);

  execlp("sort", "sort", "-g", NULL);
  perror("execlp");
  abort();
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x28b7
testl %eax, %eax
jne 0x15ae
movl %ebx, %edi
xorl %esi, %esi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x15cb
leaq 0x1c9c(%rip), %rdi      # 0x3238
leaq 0x1a86(%rip), %rsi      # 0x3029
leaq 0x1c65(%rip), %rcx      # 0x320f
pushq $0x16
jmp 0x15c5
leaq 0x1c32(%rip), %rdi      # 0x31e7
leaq 0x1a6d(%rip), %rsi      # 0x3029
leaq 0x1c4c(%rip), %rcx      # 0x320f
pushq $0x14
popq %rdx
callq 0x10e0
leaq 0x1c8a(%rip), %rdi      # 0x325c
leaq 0x1c88(%rip), %rdx      # 0x3261
movq %rdi, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1220
leaq 0x1c78(%rip), %rdi      # 0x3264
callq 0x11e0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: fizzer_main
static void *fizzer_main() {
  char buf[99];
  for (int i = 1; i < MAX; i++) {
    if (i % 3 == 0) {
      snprintf(buf, sizeof buf, "%d fizz\n", i);
      echo_upper(buf);
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
pushq $0x1
popq %rbx
movb $0x3, %bpl
leaq 0x1c5c(%rip), %r14      # 0x326b
movq %rsp, %r15
pushq $0x63
popq %r12
movzbl %bl, %eax
divb %bpl
cmpl $0x63, %ebx
je 0x1649
movzbl %al, %eax
imull $-0x3, %eax, %eax
addb %bl, %al
jne 0x1645
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1658
incl %ebx
jmp 0x1616
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: echo_upper_main
static void echo_upper_main(libforks_ServerConn conn, int socket_fd) {
  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  int out, ready_fd;
  char c;
  assert(libforks_read_socket_fds(socket_fd, &c, 1, &out, 1) == 0);
  assert(c == 'a');
  assert(libforks_read_socket_fds(socket_fd, &c, 1, &ready_fd, 1) == 0);
  assert(c == 'b');

  assert(dup2(socket_fd, STDIN_FILENO) != -1);
  assert(dup2(out, STDOUT_FILENO) != -1);
  close(socket_fd);
  close(out);

  // Inform the parent process that we’re ready to receive input
  assert(write(ready_fd, "c", 1) == 1);
  close(ready_fd);

  execlp("tr", "tr", "[:lower:]", "[:upper:]", NULL); // uppercase!
  perror("execlp");
  abort();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
callq 0x28b7
testl %eax, %eax
jne 0x1909
leaq 0x7(%rsp), %rsi
leaq 0xc(%rsp), %rcx
pushq $0x1
popq %rdx
movl %ebx, %edi
movq %rdx, %r8
callq 0x1a98
testl %eax, %eax
jne 0x1922
cmpb $0x61, 0x7(%rsp)
jne 0x193b
leaq 0x7(%rsp), %rsi
leaq 0x8(%rsp), %rcx
pushq $0x1
popq %rdx
movl %ebx, %edi
movq %rdx, %r8
callq 0x1a98
testl %eax, %eax
jne 0x1954
cmpb $0x62, 0x7(%rsp)
jne 0x196d
movl %ebx, %edi
xorl %esi, %esi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x198a
leaq 0x1941(%rip), %rdi      # 0x3238
leaq 0x172b(%rip), %rsi      # 0x3029
leaq 0x1b02(%rip), %rcx      # 0x3407
pushq $0x28
jmp 0x1984
leaq 0x18d7(%rip), %rdi      # 0x31e7
leaq 0x1712(%rip), %rsi      # 0x3029
leaq 0x1ae9(%rip), %rcx      # 0x3407
pushq $0x1f
jmp 0x1984
leaq 0x1b0d(%rip), %rdi      # 0x3436
leaq 0x16f9(%rip), %rsi      # 0x3029
leaq 0x1ad0(%rip), %rcx      # 0x3407
pushq $0x23
jmp 0x1984
leaq 0x1b2d(%rip), %rdi      # 0x346f
leaq 0x16e0(%rip), %rsi      # 0x3029
leaq 0x1ab7(%rip), %rcx      # 0x3407
pushq $0x24
jmp 0x1984
leaq 0x1b1d(%rip), %rdi      # 0x3478
leaq 0x16c7(%rip), %rsi      # 0x3029
leaq 0x1a9e(%rip), %rcx      # 0x3407
pushq $0x25
jmp 0x1984
leaq 0x1b42(%rip), %rdi      # 0x34b6
leaq 0x16ae(%rip), %rsi      # 0x3029
leaq 0x1a85(%rip), %rcx      # 0x3407
pushq $0x26
popq %rdx
callq 0x10e0
movl 0xc(%rsp), %edi
pushq $0x1
popq %rsi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x19b4
leaq 0x1b1d(%rip), %rdi      # 0x34bf
leaq 0x1680(%rip), %rsi      # 0x3029
leaq 0x1a57(%rip), %rcx      # 0x3407
pushq $0x29
jmp 0x1984
movl %ebx, %edi
callq 0x10f0
movl 0xc(%rsp), %edi
callq 0x10f0
movl 0x8(%rsp), %edi
leaq 0x1675(%rip), %rsi      # 0x3044
pushq $0x1
popq %rdx
callq 0x1080
cmpq $0x1, %rax
jne 0x1a19
movl 0x8(%rsp), %edi
callq 0x10f0
leaq 0x1b0e(%rip), %rdi      # 0x34fb
leaq 0x1b0a(%rip), %rdx      # 0x34fe
leaq 0x1b0d(%rip), %rcx      # 0x3508
movq %rdi, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1220
leaq 0x1855(%rip), %rdi      # 0x3264
callq 0x11e0
callq 0x1040
leaq 0x1abe(%rip), %rdi      # 0x34de
leaq 0x1602(%rip), %rsi      # 0x3029
leaq 0x19d9(%rip), %rcx      # 0x3407
pushq $0x2e
jmp 0x1984
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: buzzer_main
static void *buzzer_main() {
  char buf[99];
  for (int i = 1; i < MAX; i++) {
    if (i % 5 == 0) {
      snprintf(buf, sizeof buf, "%d buzz\n", i);
      echo_upper(buf);
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
pushq $0x1
popq %rbx
movb $0x5, %bpl
leaq 0x1ac4(%rip), %r14      # 0x3512
movq %rsp, %r15
pushq $0x63
popq %r12
movzbl %bl, %eax
divb %bpl
cmpl $0x63, %ebx
je 0x1a88
movzbl %al, %eax
imull $-0x5, %eax, %eax
addb %bl, %al
jne 0x1a84
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1658
incl %ebx
jmp 0x1a55
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: selftest
static int
selftest(void)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	char hbuf_hex[33];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing MD5 of \"%s\"...", tests[i].s);
		MD5_Init(&ctx);
		MD5_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		MD5_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 16);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed MD5: %s\n", hbuf_hex);
			printf("Correct MD5:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
pushq $0x8
popq %r13
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
cmpq $0x98, %r13
je 0x1553
leaq 0x58b9(%rip), %rax      # 0x6d60
movq -0x8(%r13,%rax), %rbx
movq (%r13,%rax), %rbp
leaq 0x2b63(%rip), %rdi      # 0x401b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x1618
movq %rbx, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1628
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e63
movq %rbx, %rdi
movq %r12, %rsi
pushq $0x10
popq %rdx
callq 0x29bc
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1130
testl %eax, %eax
je 0x153e
leaq 0x2e48(%rip), %rdi      # 0x435a
callq 0x1090
leaq 0x2b16(%rip), %rdi      # 0x4034
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x2b17(%rip), %rdi      # 0x4046
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x154a
leaq 0x2e0c(%rip), %rdi      # 0x4351
callq 0x1090
addq $0x10, %r13
jmp 0x1493
xorl %eax, %eax
testq %r15, %r15
setne %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	MD5_Init(&ctx);
	for (i = 0; i < nreps; i++)
		MD5_Update(&ctx, buf, buflen);
	MD5_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1618
subq $0x1, %rbx
jb 0x15fb
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1628
jmp 0x15e5
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1e63
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/st.c
// Function: selclear
void
selclear(void)
{
  if (sel.ob.x == -1)
    return;
  sel.mode = SEL_IDLE;
  sel.ob.x = -1;
  tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
cmpl $-0x1, 0x17833(%rip)    # 0x1e684
je 0x6e72
andl $0x0, 0x1780e(%rip)     # 0x1e668
orl $-0x1, 0x17823(%rip)    # 0x1e684
movl 0x17811(%rip), %edi     # 0x1e678
movl 0x17813(%rip), %esi     # 0x1e680
jmp 0x6f6b
retq