LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Func_init_pos
Func *Func_init_pos(int name, int num_args, IntRefVector *local_name_map,
        Comm *body, int src_line_no, int src_char_no) {

    Func *func           = challoc(sizeof(Func));
    func->name           = name;
    func->num_args       = num_args;
    func->local_name_map = local_name_map;
    func->body           = body;
    func->src_line_no    = src_line_no;
    func->src_char_no    = src_char_no;
    return func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %r13d
movl %edi, %ebx
movl $0x20, %edi
callq 0x62ec
movl %ebx, (%rax)
movl %r13d, 0x4(%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x18(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x1c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Comm_eq
bool Comm_eq(Comm *c1, Comm *c2) {
    if((!c1) || (!c2))  { return c1 == c2; } // Null check
    else {
        return ((c1->type) == (c2->type)) &&
                ((c1->name) == (c2->name)) &&
                Expr_eq(c1->expr, c2->expr) &&
                Comm_eq(c1->comm1, c2->comm1) &&
                Comm_eq(c1->comm2, c2->comm2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
testq %r14, %r14
je 0x9731
testq %rbx, %rbx
je 0x9731
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x973b
movl 0x20(%r14), %eax
cmpl 0x20(%rbx), %eax
jne 0x973b
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x9bc8
testl %eax, %eax
je 0x973b
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x96d8
testl %eax, %eax
je 0x973b
movq 0x18(%r14), %r14
movq 0x18(%rbx), %rbx
jmp 0x96eb
xorl %r15d, %r15d
cmpq %rbx, %r14
sete %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Comm_free
void Comm_free(Comm *comm) {
    if(!comm) { return; } // Null check
    Expr_free(comm->expr);
    Comm_free(comm->comm1);
    Comm_free(comm->comm2);
    free(comm);
}

// Assembly:
testq %rdi, %rdi
je 0x9956
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9e4a
movq 0x10(%rbx), %rdi
callq 0x991f
movq 0x18(%rbx), %rdi
callq 0x991f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Comm_init
Comm *Comm_init(CommType type, Expr *expr, Comm *comm1, Comm *comm2, int name,
        int src_line_no, int src_char_no) {

    Comm *new        = challoc(sizeof(Comm));
    new->type        = type;
    new->expr        = expr;
    new->comm1       = comm1;
    new->comm2       = comm2;
    new->name        = name;
    new->src_line_no = src_line_no;
    new->src_char_no = src_char_no;
    return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebx
movl $0x30, %edi
callq 0x62ec
movl %ebx, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x24(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Expr_eq
bool Expr_eq(Expr *e1, Expr *e2) {
    if((!e1) || (!e2))  { return e1 == e2; } // Null check
    else {
        return ((e1->type) == (e2->type)) &&
                ((e1->num) == (e2->num)) &&
                Expr_eq(e1->expr1, e2->expr1) &&
                Expr_eq(e1->expr2, e2->expr2) &&
                (((e1->args) && (e2->args)) ?
                        ExprVector_eq(e1->args, e2->args) :
                        ((e1->args) == (e2->args)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x9c35
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x9c3d
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0x9c3d
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x9bc8
testl %eax, %eax
je 0x9c3d
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x9bc8
testl %eax, %eax
je 0x9c3d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x9c47
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x9c47
callq 0xab05
testl %eax, %eax
setne %al
jmp 0x9c3f
cmpq %rbx, %r14
sete %al
jmp 0x9c3f
xorl %eax, %eax
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpq 0x18(%rbx), %rdi
jmp 0x9c38
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Expr_free
void Expr_free(Expr *expr) {
    if(!expr) { return; } // Null check
    Expr_free(expr->expr1);
    Expr_free(expr->expr2);
    ExprVector_free_elems(expr->args);
    free(expr);
}

// Assembly:
testq %rdi, %rdi
je 0x9e81
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9e4a
movq 0x10(%rbx), %rdi
callq 0x9e4a
movq 0x18(%rbx), %rdi
callq 0xa65a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/syntax.c
// Function: Expr_init
DEFINE_VECTORABLE(Expr)

Expr *Expr_init(ExprType type, int num, Expr *expr1, Expr *expr2,
        ExprVector *args, int src_line_no, int src_char_no) {

    Expr *expr        = challoc(sizeof(Expr));
    expr->type        = type;
    expr->num         = num;
    expr->expr1       = expr1;
    expr->expr2       = expr2;
    expr->args        = args;
    expr->src_line_no = src_line_no;
    expr->src_char_no = src_char_no;
    return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %r13d
movl %edi, %ebx
movl $0x28, %edi
callq 0x62ec
movl %ebx, (%rax)
movl %r13d, 0x4(%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x24(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: TypeVector_contains
DEFINE_VECTORABLE(Type)

Type *Type_init(TypeForm form, Type *innerType, TypeVector *innerTypes) {
    Type *type = challoc(sizeof(type));
    type->form = form;
    type->innerType = innerType;
    type->innerTypes = innerTypes;
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
testq %rdi, %rdi
je 0x119e1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x11a78
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x119c8
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x10dfd
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11903
testl %eax, %eax
jne 0x119cc
incl %r15d
cmpl (%r14), %r15d
jl 0x119a6
xorl %eax, %eax
jmp 0x119d1
movl $0x1, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x961c(%rip), %rdi      # 0x1b004
leaq 0xa819(%rip), %rsi      # 0x1c208
leaq 0xa8ac(%rip), %rcx      # 0x1c2a2
movl $0x9, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x9623(%rip), %rdi      # 0x1b02c
leaq 0x968a(%rip), %rsi      # 0x1b09a
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x97d4(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x11b06
movl %r14d, %r15d
leaq 0x95d2(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x11a5d
jmp 0x11b06
leaq 0x9585(%rip), %rdi      # 0x1b004
leaq 0xa782(%rip), %rsi      # 0x1c208
leaq 0xa815(%rip), %rcx      # 0x1c2a2
movl $0x9, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x958c(%rip), %rdi      # 0x1b02c
leaq 0x96b2(%rip), %rsi      # 0x1b159
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x973d(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x11b06
movl %r14d, %r15d
leaq 0x953f(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x11af0
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: Type_free
void Type_free(Type *type) {
    if(type->innerType) { Type_free(type->innerType); }
    if(type->innerTypes) { TypeVector_free(type->innerTypes); }
    free(type);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x11369
callq 0x11351
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x11383
movq 0x8(%r14), %rdi
callq 0x6030
movq %r14, %rdi
callq 0x6030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6030
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: Type_eq
bool Type_eq(Type *t1, Type *t2) {
    return ( // Do the forms match?
        t1->form == t2->form
    )
    && ( // Does the inner type match, checking for null?
        ((t1->innerType == NULL) || (t2->innerType == NULL))
                ? t1 == t2
                : Type_eq(t1->innerType, t2->innerType)
    )
    && ( // Do the inner types all match in type and sequence?
        ((t1->innerType == NULL) || (t2->innerType == NULL))
                ? t1 == t2
                : TypeVector_eq(t1->innerTypes, t2->innerTypes)
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
xorl %r15d, %r15d
cmpl (%rsi), %eax
jne 0x1196a
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x11939
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x11939
callq 0x11903
testl %eax, %eax
jne 0x1193e
jmp 0x1196a
cmpq %rbx, %r14
jne 0x1196a
cmpq $0x0, 0x8(%r14)
je 0x11960
cmpq $0x0, 0x8(%rbx)
je 0x11960
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x117f5
testl %eax, %eax
setne %al
jmp 0x11966
cmpq %rbx, %r14
sete %al
movzbl %al, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: Type_copy
Type *Type_copy(Type *old) {
    Type *new       = challoc(sizeof(Type));
    new->form       = old->form;
    new->innerType  = (old->innerType)  ? Type_copy(old->innerType)  : NULL;
    if(old->innerTypes) {
        new->innerTypes = TypeVector_init();
        int idx;
        for(idx = 0; idx < TypeVector_size(old->innerTypes); idx++) {
            TypeVector_append(new->innerTypes,
                    Type_copy(TypeVector_get(old->innerTypes, idx)));
        }
    }
    else {
        new->innerTypes = NULL;
    }
    return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x62ec
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x11bd7
callq 0x11ba7
jmp 0x11bd9
xorl %eax, %eax
movq %rax, 0x8(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x11c56
movl $0x10, %edi
callq 0x62ec
movq %rax, %r15
movabsq $0xa00000000, %rax      # imm = 0xA00000000
movq %rax, (%r15)
movl $0x50, %edi
callq 0x62ec
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r14)
movq 0x10(%rbx), %rdi
callq 0x10b6c
testl %eax, %eax
jle 0x11c5e
xorl %r15d, %r15d
movq 0x10(%r14), %r12
movq 0x10(%rbx), %rdi
movl %r15d, %esi
callq 0x10dfd
movq %rax, %rdi
callq 0x11ba7
movq %r12, %rdi
movq %rax, %rsi
callq 0x10c1e
incl %r15d
movq 0x10(%rbx), %rdi
callq 0x10b6c
cmpl %eax, %r15d
jl 0x11c20
jmp 0x11c5e
movq $0x0, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: TypeError_free
void TypeError_free(TypeError *error) {
    Type_free(error->found);
    Type_free(error->expected);
    free(error);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11351
movq 0x10(%rbx), %rdi
callq 0x11351
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: TypeError_eq
bool TypeError_eq(TypeError *error1, TypeError *error2) {
    // Null checks are essentially to supress the unused parameter warning
    if(!error1) { ERROR("Null TypeError"); }
    if(!error2) { ERROR("Null TypeError"); }
    ERROR("Equality not defined for TypeErrors");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
testq %rdi, %rdi
jne 0x12ac6
leaq 0x85ce(%rip), %rdi      # 0x1b004
leaq 0x97cb(%rip), %rsi      # 0x1c208
leaq 0x993d(%rip), %rcx      # 0x1c381
movl $0x60, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x85d5(%rip), %rdi      # 0x1b02c
leaq 0x9930(%rip), %rsi      # 0x1c38e
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x8786(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x12bed
movl %r14d, %r15d
leaq 0x8584(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x12aab
jmp 0x12bed
leaq 0x8537(%rip), %rdi      # 0x1b004
testq %rsi, %rsi
jne 0x12b66
leaq 0x972b(%rip), %rsi      # 0x1c208
leaq 0x989d(%rip), %rcx      # 0x1c381
movl $0x61, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x8535(%rip), %rdi      # 0x1b02c
leaq 0x9890(%rip), %rsi      # 0x1c38e
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x86e6(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x12bed
movl %r14d, %r15d
leaq 0x84e4(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x12b4b
jmp 0x12bed
leaq 0x969b(%rip), %rsi      # 0x1c208
leaq 0x980d(%rip), %rcx      # 0x1c381
movl $0x62, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x84a5(%rip), %rdi      # 0x1b02c
leaq 0x980f(%rip), %rsi      # 0x1c39d
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x8656(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x12bed
movl %r14d, %r15d
leaq 0x8458(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x12bd7
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/typecheck.c
// Function: TypeCheckSuccess_init
TypeCheckResult *TypeCheckSuccess_init(Type *type) {
    TypeCheckResult *res = challoc(sizeof(TypeCheckResult));
    res->success = true;
    res->type    = type;
    res->errors  = NULL;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x62ec
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x62ec
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x12e51
movq 0x8(%rbx), %rdi
callq 0x11351
jmp 0x12e5a
movq 0x10(%rbx), %rdi
callq 0x1241c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movl (%rdi), %eax
cmpl $0x2, %eax
jb 0x1325e
cmpl $0x3, %eax
je 0x1325e
cmpl $0x2, %eax
jne 0x132f5
movq 0x10(%rdi), %rdi
callq 0x1322e
leaq 0x7d9f(%rip), %rdi      # 0x1b004
leaq 0x8f9c(%rip), %rsi      # 0x1c208
leaq 0x9179(%rip), %rcx      # 0x1c3ec
movl $0xa9, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x7da6(%rip), %rdi      # 0x1b02c
leaq 0x913f(%rip), %rsi      # 0x1c3cc
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x7f57(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x13383
movl %r14d, %r15d
leaq 0x7d55(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x132da
jmp 0x13383
leaq 0x7d08(%rip), %rdi      # 0x1b004
leaq 0x8f05(%rip), %rsi      # 0x1c208
leaq 0x90e2(%rip), %rcx      # 0x1c3ec
movl $0xa8, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x7d0f(%rip), %rdi      # 0x1b02c
leaq 0x90d3(%rip), %rsi      # 0x1c3f7
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x7ec0(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x13383
movl %r14d, %r15d
leaq 0x7cc2(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1336d
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %r13d
movl $0x14, %edi
callq 0x62ec
movl %r13d, (%rax)
movl %r12d, 0x4(%rax)
movl %r15d, 0x8(%rax)
movl %r14d, 0xc(%rax)
movl %ebx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x9e82
movq %rax, %r12
movq %r14, %rdi
callq 0x75ec
testl %eax, %eax
jle 0x13792
movq %r14, %rdi
movl %r15d, %esi
callq 0x787d
movl (%rax), %edi
callq 0xae02
movq %r12, %rdi
movq %rax, %rsi
callq 0x9f6c
incl %r15d
movq %r14, %rdi
callq 0x75ec
cmpl %eax, %r15d
jl 0x13765
xorl %edi, %edi
movq %r12, %rsi
callq 0xaebd
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x137c3
movq %rax, %rbx
movq %r14, %rdi
callq 0x9e4a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
callq 0x13b47
cmpl $0x0, (%rax)
jne 0x13b40
cmpl $0x0, 0x8(%rax)
jne 0x13b40
movq %rax, %rdi
callq 0x6030
movq 0x18(%rbx), %rbx
movl $0x14, %edi
callq 0x62ec
movq $0x3, (%rax)
movl $0x0, 0x8(%rax)
movq %rbx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xc, %edi
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_O1/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 0x13e23
leaq 0x7271(%rip), %rdi      # 0x1b004
leaq 0x8722(%rip), %rsi      # 0x1c4bc
leaq 0x8727(%rip), %rcx      # 0x1c4c8
movl $0x14, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x7278(%rip), %rdi      # 0x1b02c
leaq 0x871f(%rip), %rsi      # 0x1c4da
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x7429(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x13f4a
movl %r14d, %r15d
leaq 0x7227(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x13e08
jmp 0x13f4a
leaq 0x71da(%rip), %rdi      # 0x1b004
testq %rsi, %rsi
jne 0x13ec3
leaq 0x8682(%rip), %rsi      # 0x1c4bc
leaq 0x8687(%rip), %rcx      # 0x1c4c8
movl $0x15, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x71d8(%rip), %rdi      # 0x1b02c
leaq 0x867f(%rip), %rsi      # 0x1c4da
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x7389(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x13f4a
movl %r14d, %r15d
leaq 0x7187(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x13ea8
jmp 0x13f4a
leaq 0x85f2(%rip), %rsi      # 0x1c4bc
leaq 0x85f7(%rip), %rcx      # 0x1c4c8
movl $0x16, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x7148(%rip), %rdi      # 0x1b02c
leaq 0x85fe(%rip), %rsi      # 0x1c4e9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x72f9(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x13f4a
movl %r14d, %r15d
leaq 0x70fb(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x13f34
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1417a
cmpl $0x5, %esi
ja 0x14169
movl %esi, %eax
leaq 0x837f(%rip), %rcx      # 0x1c4a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x848d(%rip), %rdi      # 0x1c5c2
jmp 0x14162
leaq 0x84bf(%rip), %rdi      # 0x1c5fd
jmp 0x14162
leaq 0x8497(%rip), %rdi      # 0x1c5de
jmp 0x14162
leaq 0x849d(%rip), %rdi      # 0x1c5ed
jmp 0x14162
leaq 0x8477(%rip), %rdi      # 0x1c5d0
jmp 0x14162
leaq 0x84a7(%rip), %rdi      # 0x1c609
xorl %eax, %eax
jmp 0x6100
addl $-0x6, %esi
leaq 0x84a0(%rip), %rdi      # 0x1c613
xorl %eax, %eax
jmp 0x6100
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
leaq 0x8403(%rip), %rdi      # 0x1c596
xorl %eax, %eax
callq 0x6100
leaq 0x6e63(%rip), %rdi      # 0x1b004
leaq 0x8314(%rip), %rsi      # 0x1c4bc
leaq 0x83f8(%rip), %rcx      # 0x1c5a7
movl $0x63, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x6e6a(%rip), %rdi      # 0x1b02c
leaq 0x83e8(%rip), %rsi      # 0x1c5b1
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x701b(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x14228
movl %r14d, %r15d
leaq 0x6e1d(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x14212
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/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 0x86b3
leal (,%rax,4), %edi
callq 0x62ec
movq %rax, %r15
movq (%r14), %rdi
callq 0x86b3
testl %eax, %eax
jle 0x151c7
xorl %r12d, %r12d
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
movl %eax, (%r15,%r12,4)
incq %r12
movq (%r14), %rdi
callq 0x86b3
cltq
cmpq %rax, %r12
jl 0x151aa
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x14232
movq %rax, %r12
movl (%r15), %esi
movl $0x8, %edi
xorl %edx, %edx
callq 0x13d40
movq %r12, %rdi
movq %rax, %rsi
callq 0x1431c
movl $0xb, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d40
movq %r12, -0x30(%rbp)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1431c
movq (%r14), %rdi
callq 0x86b3
testl %eax, %eax
jle 0x1525a
movq (%r14), %rdi
movl %r13d, %esi
callq 0x883f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x15275
movq %rax, %r12
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1440b
movq %r12, %rdi
callq 0x149e4
incl %r13d
movq (%r14), %rdi
callq 0x86b3
cmpl %eax, %r13d
jl 0x15217
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_O1/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 0x14232
movq %rax, %rbx
movl $0xa, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x13d40
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1431c
movq 0x10(%r12), %rsi
movq %r13, %rdi
movq -0x30(%rbp), %rdx
movq %r14, %rcx
callq 0x152f7
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1440b
movq %r14, %rdi
callq 0x149e4
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_O1/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 0x15c2e
movq %rax, %rbx
movq %rax, %rdi
callq 0x15f2d
movq %rbx, %rdi
callq 0x15f5e
movl %eax, %r14d
movq %rbx, %rdi
callq 0x16036
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rdi), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
callq 0x144fb
cmpl $0xb, (%rax)
je 0x15f57
movq %rbx, %rdi
callq 0x161e0
movq (%rbx), %rdi
jmp 0x15f39
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x144fb
cmpl $0xb, (%rax)
jne 0x15f9e
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 0x505f(%rip), %rdi      # 0x1b004
leaq 0x6818(%rip), %rsi      # 0x1c7c4
leaq 0x68e3(%rip), %rcx      # 0x1c896
movl $0xb3, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x5066(%rip), %rdi      # 0x1b02c
leaq 0x68e6(%rip), %rsi      # 0x1c8b3
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x5217(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1602c
movl %r14d, %r15d
leaq 0x5019(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x16016
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6030
movq 0x10(%rbx), %rdi
callq 0x6030
movq 0x18(%rbx), %rdi
callq 0x6030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
// File: /workspace/github_c_makefile_star2_O1/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 0x160b1
testl %edi, %edi
js 0x16148
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f4c(%rip), %rdi      # 0x1b004
leaq 0x6705(%rip), %rsi      # 0x1c7c4
leaq 0x6788(%rip), %rcx      # 0x1c84e
movl $0x95, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x4f53(%rip), %rdi      # 0x1b02c
leaq 0x6797(%rip), %rsi      # 0x1c877
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x5104(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x161d6
movl %r14d, %r15d
leaq 0x4f02(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1612d
jmp 0x161d6
leaq 0x4eb5(%rip), %rdi      # 0x1b004
leaq 0x666e(%rip), %rsi      # 0x1c7c4
leaq 0x66f1(%rip), %rcx      # 0x1c84e
movl $0x98, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x4ebc(%rip), %rdi      # 0x1b02c
leaq 0x670f(%rip), %rsi      # 0x1c886
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x506d(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x161d6
movl %r14d, %r15d
leaq 0x4e6f(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x161c0
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1426a
shll $0x4, %eax
leal (%rax,%rax,2), %edi
callq 0x62ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x1426a
testl %eax, %eax
jle 0x163f9
xorl %r15d, %r15d
movq %r14, %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x144fb
movq (%rax), %rcx
movq %rcx, (%r12)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r12)
addq $0x30, %r12
incl %r15d
movq %rbx, %rdi
callq 0x1426a
cmpl %eax, %r15d
jl 0x163cb
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1645b
movq %rax, %rbx
movq %rax, %rdi
callq 0x164be
movq 0x10(%rbx), %rax
movl 0x10(%rax), %r14d
movq %rbx, %rdi
callq 0x16660
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15c2e
movq %rax, %r14
movl $0x28, %edi
callq 0x62ec
movq %rax, %r15
movq %rbx, %rdi
callq 0x16398
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_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6030
movq 0x8(%rbx), %rdi
callq 0x6030
movq 0x10(%rbx), %rdi
callq 0x6030
movq 0x18(%rbx), %rdi
callq 0x6030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6030
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %edi
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_O1/alexj136[P]minijit/src/ncodegen.c
// Function: LinkTargetVector_remove
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 0x17e7e
movl %esi, %r14d
testl %esi, %esi
js 0x17f15
movq %rdi, %rbx
cmpl %r14d, (%rdi)
jle 0x17fac
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1768a
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x17bde
decl (%rbx)
movq %r15, %rax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x317f(%rip), %rdi      # 0x1b004
leaq 0x4bf8(%rip), %rsi      # 0x1ca84
leaq 0x4c8e(%rip), %rcx      # 0x1cb21
movl $0x15, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x3186(%rip), %rdi      # 0x1b02c
leaq 0x31ed(%rip), %rsi      # 0x1b09a
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x3337(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1803a
movl %r14d, %r15d
leaq 0x3135(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x17efa
jmp 0x1803a
leaq 0x30e8(%rip), %rdi      # 0x1b004
leaq 0x4b61(%rip), %rsi      # 0x1ca84
leaq 0x4bf7(%rip), %rcx      # 0x1cb21
movl $0x15, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x30ef(%rip), %rdi      # 0x1b02c
leaq 0x319c(%rip), %rsi      # 0x1b0e0
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x32a0(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1803a
movl %r14d, %r15d
leaq 0x309e(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x17f91
jmp 0x1803a
leaq 0x3051(%rip), %rdi      # 0x1b004
leaq 0x4aca(%rip), %rsi      # 0x1ca84
leaq 0x4b60(%rip), %rcx      # 0x1cb21
movl $0x15, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x3058(%rip), %rdi      # 0x1b02c
leaq 0x3115(%rip), %rsi      # 0x1b0f0
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x3209(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1803a
movl %r14d, %r15d
leaq 0x300b(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x18024
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: TestProgramVector_remove
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 0x191af
movl %esi, %r14d
testl %esi, %esi
js 0x19246
movq %rdi, %rbx
cmpl %r14d, (%rdi)
jle 0x192dd
movq %rbx, %rdi
movl %r14d, %esi
callq 0x189b1
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x18f0f
decl (%rbx)
movq %r15, %rax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e4e(%rip), %rdi      # 0x1b004
leaq 0x39c4(%rip), %rsi      # 0x1cb81
leaq 0x3a68(%rip), %rcx      # 0x1cc2c
movl $0x7, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1e55(%rip), %rdi      # 0x1b02c
leaq 0x1ebc(%rip), %rsi      # 0x1b09a
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x2006(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1936b
movl %r14d, %r15d
leaq 0x1e04(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1922b
jmp 0x1936b
leaq 0x1db7(%rip), %rdi      # 0x1b004
leaq 0x392d(%rip), %rsi      # 0x1cb81
leaq 0x39d1(%rip), %rcx      # 0x1cc2c
movl $0x7, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1dbe(%rip), %rdi      # 0x1b02c
leaq 0x1e6b(%rip), %rsi      # 0x1b0e0
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x1f6f(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1936b
movl %r14d, %r15d
leaq 0x1d6d(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x192c2
jmp 0x1936b
leaq 0x1d20(%rip), %rdi      # 0x1b004
leaq 0x3896(%rip), %rsi      # 0x1cb81
leaq 0x393a(%rip), %rcx      # 0x1cc2c
movl $0x7, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1d27(%rip), %rdi      # 0x1b02c
leaq 0x1de4(%rip), %rsi      # 0x1b0f0
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x1ed8(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1936b
movl %r14d, %r15d
leaq 0x1cda(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19355
movl $0x1, %edi
callq 0x61a0