LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/alloc.cpp
// Function: allocate(unsigned long, MEM)
void *allocate(size_t n, MEM enum_ar) {
    int ar = (int) enum_ar;
    block_t *ap = arena[ar];
    assert(ap);
    
    n = roundup(n, ALIGN_SIZE);
    if (n > (ap->limit - ap->avail)) {
        ap->next = freeblocks;
        if (ap->next != NULL) {
            do {
                freeblocks = freeblocks->next;
                ap = ap->next;
            } while(n > (ap->limit - ap->avail));
        } else {  // Need to allocate
            size_t sz = sizeof(block_t) + n + roundup(BLOCK_TAIL, ALIGN_SIZE);
            // Set `next` to the new block first so that if this is the first block
            // in the arena `ar`, then first[ar].next will be set to this new block.
            ap->next = (block_t *)malloc(sz);
            ap = ap->next;
            assert(ap && "Insufficient memory");
            ap->limit = (uint8_t*)ap + sz;
        }
        ap->avail = (uint8_t*)(ap + 1);
        ap->next = NULL;
        arena[ar] = ap;
    }
    ap->avail += n;
    void *ret = (void*)(ap->avail - n);
    assert(ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %r12
leaq 0x17e11(%rip), %r13     # 0x1a100
movq (%r13,%r12,8), %r15
testq %r15, %r15
je 0x2392
movq %rdi, %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
cmpq %rcx, %rbx
jbe 0x237c
movq 0x182d9(%rip), %rax     # 0x1a5f8
movq %rax, (%r15)
testq %rax, %rax
je 0x2343
movq (%rax), %rax
movq %rax, 0x182c7(%rip)     # 0x1a5f8
movq (%r15), %r15
movq 0x10(%r15), %rcx
subq 0x8(%r15), %rcx
cmpq %rcx, %rbx
ja 0x2327
jmp 0x2364
leaq 0x2818(%rbx), %r14
movq %r14, %rdi
callq 0x2150
movq %rax, (%r15)
testq %rax, %rax
je 0x23d0
addq %rax, %r14
movq %r14, 0x10(%rax)
movq %rax, %r15
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movq %r15, (%r13,%r12,8)
movq 0x8(%r15), %rax
addq %rax, %rbx
movq %rbx, 0x8(%r15)
testq %rax, %rax
je 0x23b1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1266f(%rip), %rdi     # 0x14a08
leaq 0xec64(%rip), %rsi      # 0x11004
leaq 0xec67(%rip), %rcx      # 0x1100e
movl $0x41, %edx
callq 0x20b0
leaq 0xec8e(%rip), %rdi      # 0x11046
leaq 0xec45(%rip), %rsi      # 0x11004
leaq 0xec48(%rip), %rcx      # 0x1100e
movl $0x5a, %edx
callq 0x20b0
leaq 0xec53(%rip), %rdi      # 0x1102a
leaq 0xec26(%rip), %rsi      # 0x11004
leaq 0xec29(%rip), %rcx      # 0x1100e
movl $0x51, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/alloc.cpp
// Function: deallocate(MEM)
void deallocate(MEM enum_ar) {
    int ar = (int) enum_ar;
    // Check for double deallocation.
    if (arena[ar]->next == NULL) return;
    // Connect the arena's last block with the start of free blocks list
    arena[ar]->next = freeblocks;
    // Now point the start of the free blocks list to the first block of the arena
    // (which is the start of the chain connecting arena's block and the free blocks)
    freeblocks = first[ar].next;
    // Set the arena's first block to nothing again.
    first[ar].next = NULL;
    // Point again the arena to the first empty element
    arena[ar] = &first[ar];
}

// Assembly:
movslq %edi, %rax
leaq 0x17cf0(%rip), %rcx     # 0x1a100
movq (%rcx,%rax,8), %rdx
cmpq $0x0, (%rdx)
je 0x2448
movq 0x181d7(%rip), %rsi     # 0x1a5f8
movq %rsi, (%rdx)
leaq (%rax,%rax,2), %rdx
leaq 0x18121(%rip), %rsi     # 0x1a550
leaq (%rsi,%rdx,8), %rdx
movq (%rdx), %rsi
movq %rsi, 0x181bb(%rip)     # 0x1a5f8
movq $0x0, (%rdx)
movq %rdx, (%rcx,%rax,8)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: expr_name(EXPR)
const char *expr_name(EXPR kind) {
    static const char* expr_names[(int)EXPR::__LAST - (int)EXPR::__FIRST + 1];

    expr_names[(int)EXPR::AND] = "AndExpression";
    expr_names[(int)EXPR::CMP] = "CmpExpression";
    expr_names[(int)EXPR::PLUS] = "PlusExpression +";
    expr_names[(int)EXPR::MINUS] = "MinusExpression -";
    expr_names[(int)EXPR::TIMES] = "TimesExpression *";
    expr_names[(int)EXPR::ARR_LOOK] = "ArrayLookup";
    expr_names[(int)EXPR::ARR_LEN] = "ArrayLength";
    expr_names[(int)EXPR::MSG_SEND] = "MessageSend";
    expr_names[(int)EXPR::NOT] = "NotExpression";
    expr_names[(int)EXPR::ID] = "Identifier";
    expr_names[(int)EXPR::INT_LIT] = "IntegerLiteral";
    expr_names[(int)EXPR::BOOL_LIT] = "BoolLiteral";
    expr_names[(int)EXPR::THIS] = "ThisExpression";
    expr_names[(int)EXPR::ARR_ALLOC] = "ArrayAllocationExpression";
    expr_names[(int)EXPR::ALLOC] = "AllocationExpression";
    expr_names[(int)EXPR::UNDEFINED] = "Undefined (Error)";

    return expr_names[(int)kind];
}

// Assembly:
leaq 0xece5(%rip), %rax      # 0x11138
movq %rax, 0x181ae(%rip)     # 0x1a608
leaq 0x1819f(%rip), %rax     # 0x1a600
leaq 0xecde(%rip), %rcx      # 0x11146
movq %rcx, 0x181a1(%rip)     # 0x1a610
leaq 0xecde(%rip), %rcx      # 0x11154
movq %rcx, 0x1819b(%rip)     # 0x1a618
leaq 0xece1(%rip), %rcx      # 0x11165
movq %rcx, 0x18195(%rip)     # 0x1a620
leaq 0xece5(%rip), %rcx      # 0x11177
movq %rcx, 0x1818f(%rip)     # 0x1a628
leaq 0xece9(%rip), %rcx      # 0x11189
movq %rcx, 0x18189(%rip)     # 0x1a630
leaq 0xece7(%rip), %rcx      # 0x11195
movq %rcx, 0x18183(%rip)     # 0x1a638
leaq 0xece5(%rip), %rcx      # 0x111a1
movq %rcx, 0x1817d(%rip)     # 0x1a640
leaq 0xece3(%rip), %rcx      # 0x111ad
movq %rcx, 0x18177(%rip)     # 0x1a648
leaq 0xece3(%rip), %rcx      # 0x111bb
movq %rcx, 0x18171(%rip)     # 0x1a650
leaq 0xece0(%rip), %rcx      # 0x111c6
movq %rcx, 0x1816b(%rip)     # 0x1a658
leaq 0xece1(%rip), %rcx      # 0x111d5
movq %rcx, 0x18165(%rip)     # 0x1a660
leaq 0xecdf(%rip), %rcx      # 0x111e1
movq %rcx, 0x1815f(%rip)     # 0x1a668
leaq 0xece0(%rip), %rcx      # 0x111f0
movq %rcx, 0x18159(%rip)     # 0x1a670
leaq 0xecd7(%rip), %rcx      # 0x111f5
movq %rcx, 0x18153(%rip)     # 0x1a678
leaq 0xecde(%rip), %rcx      # 0x1120a
movq %rcx, 0x180cd(%rip)     # 0x1a600
movslq %edi, %rcx
movq (%rax,%rcx,8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: BlockStatement::print() const
void BlockStatement::print() const {
    LOG_SCOPE;
    debug_line("(BlockStatement");
    for (const Statement *stmt : this->block) {
        stmt->print();
    }
    debug_line(")");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe769(%rip), %rdi      # 0x112d8
xorl %eax, %eax
callq 0x35e6
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2b9d
movq 0x20(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r15, %r14
jne 0x2b8a
leaq 0x10c87(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2bc1
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: AssignmentStatement::print() const
void AssignmentStatement::print() const {
    LOG_SCOPE;
    debug_line("(AssignmentStatement");
    debug_print("- Identifier: %s\n", this->id);
    expr_print(this->rhs);
    debug_line(")");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe6f9(%rip), %rdi      # 0x112e8
xorl %eax, %eax
callq 0x35e6
movq 0x10(%rbx), %rsi
leaq 0xe6fc(%rip), %rdi      # 0x112fd
xorl %eax, %eax
callq 0x3539
movq 0x18(%rbx), %rdi
callq 0x253b
leaq 0x10c13(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: ArrayAssignmentStatement::print() const
void ArrayAssignmentStatement::print() const {
    LOG_SCOPE;
    debug_line("(ArrayAssignmentStatement");
    debug_print("- Identifier: %s\n", this->id);
    expr_print(this->index);
    expr_print(this->rhs);
    debug_line(")");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe6b2(%rip), %rdi      # 0x1130f
xorl %eax, %eax
callq 0x35e6
movq 0x10(%rbx), %rsi
leaq 0xe68e(%rip), %rdi      # 0x112fd
xorl %eax, %eax
callq 0x3539
movq 0x18(%rbx), %rdi
callq 0x253b
movq 0x20(%rbx), %rdi
callq 0x253b
leaq 0x10b9c(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: IfStatement::print() const
void IfStatement::print() const {
    LOG_SCOPE;
    debug_line("(IfStatement");
    debug_print("- Cond: \n");
    {
        LOG_SCOPE;
        expr_print(this->cond);
    }
    debug_print("- Then: \n");
    {
        LOG_SCOPE;
        this->then->print();
    }
    debug_print("- Else: \n");
    {
        LOG_SCOPE;
        this->else_->print();
    }
    debug_line(")");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe654(%rip), %rdi      # 0x11329
xorl %eax, %eax
callq 0x35e6
leaq 0xe653(%rip), %rdi      # 0x11336
xorl %eax, %eax
callq 0x3539
leaq 0xe(%rsp), %rdi
callq 0x34c8
movq 0x10(%rbx), %rdi
callq 0x253b
leaq 0xe(%rsp), %rdi
callq 0x34dc
leaq 0xe632(%rip), %rdi      # 0x11340
xorl %eax, %eax
callq 0x3539
leaq 0xd(%rsp), %rdi
callq 0x34c8
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x34dc
leaq 0xe610(%rip), %rdi      # 0x1134a
xorl %eax, %eax
callq 0x3539
leaq 0xc(%rsp), %rdi
callq 0x34c8
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xc(%rsp), %rdi
callq 0x34dc
leaq 0x10ac5(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x2d9d
jmp 0x2da6
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x2d9d
jmp 0x2da6
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x34dc
jmp 0x2da9
jmp 0x2da6
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: WhileStatement::print() const
void WhileStatement::print() const {
    LOG_SCOPE;
    debug_line("(WhileStatement");
    debug_print("- Cond: \n");
    {
        LOG_SCOPE;
        expr_print(this->cond);
    }
    debug_print("- Body: \n");
    {
        LOG_SCOPE;
        this->body->print();
    }
    debug_line(")");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe57f(%rip), %rdi      # 0x11354
xorl %eax, %eax
callq 0x35e6
leaq 0xe553(%rip), %rdi      # 0x11336
xorl %eax, %eax
callq 0x3539
leaq 0xe(%rsp), %rdi
callq 0x34c8
movq 0x10(%rbx), %rdi
callq 0x253b
leaq 0xe(%rsp), %rdi
callq 0x34dc
leaq 0xe556(%rip), %rdi      # 0x11364
xorl %eax, %eax
callq 0x3539
leaq 0xd(%rsp), %rdi
callq 0x34c8
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x34dc
leaq 0x109f1(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x2e65
jmp 0x2e6e
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x34dc
jmp 0x2e71
jmp 0x2e6e
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: PrintStatement::print() const
void PrintStatement::print() const {
    LOG_SCOPE;
    debug_line("(PrintStatement");
    expr_print(this->to_print);
    debug_line(")");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0xe4d1(%rip), %rdi      # 0x1136e
xorl %eax, %eax
callq 0x35e6
movq 0x10(%rbx), %rdi
callq 0x253b
leaq 0x10977(%rip), %rdi     # 0x1382b
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: typespec_print(Typespec)
void typespec_print(Typespec tspec) {
    switch (tspec.kind) {
    case TYSPEC::UNDEFINED:
    {
        printf("Undefined Typespec (Error)");
    } break;
    case TYSPEC::ARR:
    {
        printf("int[]");
    } break;
    case TYSPEC::INT:
    {
        printf("int");
    } break;
    case TYSPEC::BOOL:
    {
        printf("boolean");
    } break;
    case TYSPEC::ID:
    {
        printf("Id Type: %s", tspec.id);
    } break;
    default: assert(0);
    }
}

// Assembly:
cmpl $0x4, %edi
ja 0x2f2e
movl %edi, %eax
leaq 0xe19a(%rip), %rcx      # 0x11088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe480(%rip), %rdi      # 0x1137e
jmp 0x2f27
leaq 0xe4a4(%rip), %rdi      # 0x113ab
xorl %eax, %eax
jmp 0x2030
leaq 0xe48a(%rip), %rdi      # 0x1139f
jmp 0x2f27
leaq 0xe485(%rip), %rdi      # 0x113a3
jmp 0x2f27
leaq 0xe472(%rip), %rdi      # 0x11399
xorl %eax, %eax
jmp 0x2030
pushq %rax
leaq 0x106ec(%rip), %rdi     # 0x13622
leaq 0xe358(%rip), %rsi      # 0x11295
leaq 0xe473(%rip), %rcx      # 0x113b7
movl $0xcd, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: TypeDeclaration::print() const
void TypeDeclaration::print() const {
    LOG_SCOPE;
    if (this->is_undefined()) {
        debug_line("Undefined TypeDeclaration (Error)");
        return;
    }
    debug_print("(TypeDeclaration %s", this->id);
    if (this->extends) {
        printf(" _EXTENDS_ %s\n", this->extends);
    } else {
        printf("\n");
    }
    {
        LOG_SCOPE;
        debug_print("Member Vars:\n");
        for (LocalDeclaration *ld : this->vars) {
            ld->print();
        }
    }
    {
        LOG_SCOPE;
        debug_print("Member Methods:\n");
        {
            for (MethodDeclaration *md : this->methods) {
                md->print();
            }
        }
    }
    debug_print(")\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34c8
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
orq %rsi, %rax
jne 0x2fb9
leaq 0xe454(%rip), %rdi      # 0x11401
xorl %eax, %eax
callq 0x35e6
jmp 0x3088
leaq 0xe463(%rip), %rdi      # 0x11423
xorl %eax, %eax
callq 0x3539
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2fe0
leaq 0xe460(%rip), %rdi      # 0x11437
xorl %eax, %eax
callq 0x2030
jmp 0x2fea
movl $0xa, %edi
callq 0x2160
leaq 0x6(%rsp), %rdi
callq 0x34c8
leaq 0xe44b(%rip), %rdi      # 0x11446
xorl %eax, %eax
callq 0x3539
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x3028
movq 0x28(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30d4
addq $0x8, %r12
cmpq %r12, %r14
jne 0x3016
leaq 0x6(%rsp), %rdi
callq 0x34dc
leaq 0x5(%rsp), %rdi
callq 0x34c8
leaq 0xe411(%rip), %rdi      # 0x11454
xorl %eax, %eax
callq 0x3539
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x3070
movq 0x40(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
callq 0x3116
addq $0x8, %r15
cmpq %r15, %r14
jne 0x305e
leaq 0x5(%rsp), %rdi
callq 0x34dc
leaq 0x11043(%rip), %rdi     # 0x140c4
xorl %eax, %eax
callq 0x3539
leaq 0x7(%rsp), %rdi
callq 0x34dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x30ab
jmp 0x30a6
jmp 0x30b5
jmp 0x30a6
movq %rax, %rbx
jmp 0x30c2
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x30bd
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x34dc
leaq 0x7(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: MethodDeclaration::print() const
void MethodDeclaration::print() const {
    LOG_SCOPE;
    if (this->is_undefined()) {
        debug_line("Undefined MethodDeclaration (Error)");
        return;
    }
    debug_print("(MethodDeclaration %s\n", this->id);
    {
        LOG_SCOPE;
        debug_print("Parameters:\n");
        {
            for (LocalDeclaration *ld: this->params) {
                ld->print();
            }
        }
    }
    {
        LOG_SCOPE;
        debug_print("Body:\n");
        {
            for (Statement *s: this->stmts) {
                if (!s->is_undefined()) {
                    s->print();
                }
            }
        }
    }
    {
        LOG_SCOPE;
        debug_print("Return:\n");
        {
            expr_print(this->ret);
        }
    }
    debug_print(")\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x3227
leaq 0xe345(%rip), %rdi      # 0x11489
xorl %eax, %eax
callq 0x3539
leaq 0xe(%rsp), %rdi
callq 0x34c8
leaq 0xe344(%rip), %rdi      # 0x114a0
xorl %eax, %eax
callq 0x3539
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x3189
movq 0x30(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30d4
addq $0x8, %r12
cmpq %r12, %r14
jne 0x3177
leaq 0xe(%rsp), %rdi
callq 0x34dc
leaq 0xd(%rsp), %rdi
callq 0x34c8
leaq 0xe309(%rip), %rdi      # 0x114ad
xorl %eax, %eax
callq 0x3539
movq 0x58(%rbx), %r15
testq %r15, %r15
je 0x31e2
movq 0x60(%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x31d9
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x31bf
leaq 0xd(%rsp), %rdi
callq 0x34dc
leaq 0xc(%rsp), %rdi
callq 0x34c8
leaq 0xe2b7(%rip), %rdi      # 0x114b4
xorl %eax, %eax
callq 0x3539
movq 0x68(%rbx), %rdi
callq 0x253b
leaq 0xc(%rsp), %rdi
callq 0x34dc
leaq 0x10ea6(%rip), %rdi     # 0x140c4
xorl %eax, %eax
callq 0x3539
jmp 0x3235
leaq 0xe237(%rip), %rdi      # 0x11465
xorl %eax, %eax
callq 0x35e6
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3261
jmp 0x3270
jmp 0x3261
jmp 0x3266
jmp 0x3261
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x3278
movq %rax, %rbx
jmp 0x327d
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
jmp 0x3278
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
callq 0x34dc
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: MainClass::print() const
void MainClass::print() const {
    LOG_SCOPE;
    debug_print("(MainClass %s\n", this->id);
    {
        LOG_SCOPE;
        debug_print("VarDeclarations of `main`:\n");
        for (LocalDeclaration *ld : this->vars) {
            ld->print();
        }
    }
    {
        LOG_SCOPE;
        debug_print("Statements of `main`:\n");
        for (Statement *s : this->stmts) {
            s->print();
        }
    }
    debug_print(")\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x34c8
movq 0x8(%rbx), %rsi
leaq 0xe20d(%rip), %rdi      # 0x114bd
xorl %eax, %eax
callq 0x3539
leaq 0x6(%rsp), %rdi
callq 0x34c8
leaq 0xe204(%rip), %rdi      # 0x114cc
xorl %eax, %eax
callq 0x3539
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x32f5
movq 0x20(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30d4
addq $0x8, %r12
cmpq %r12, %r14
jne 0x32e3
leaq 0x6(%rsp), %rdi
callq 0x34dc
leaq 0x5(%rsp), %rdi
callq 0x34c8
leaq 0xe1d8(%rip), %rdi      # 0x114e8
xorl %eax, %eax
callq 0x3539
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x333e
movq 0x38(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r15, %r14
jne 0x332b
leaq 0x5(%rsp), %rdi
callq 0x34dc
leaq 0x10d75(%rip), %rdi     # 0x140c4
xorl %eax, %eax
callq 0x3539
leaq 0x7(%rsp), %rdi
callq 0x34dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3379
jmp 0x3374
jmp 0x3383
jmp 0x3374
movq %rax, %rbx
jmp 0x3390
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x338b
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x34dc
leaq 0x7(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/ast.cpp
// Function: Goal::print() const
void Goal::print() const {
    LOG_SCOPE;
    this->main_class.print();
    for (TypeDeclaration *type_decl : this->type_decls) {
        type_decl->print();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34c8
leaq 0x8(%rbx), %rdi
callq 0x3290
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x33e7
movq 0x58(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
callq 0x2f84
addq $0x8, %r15
cmpq %r15, %r14
jne 0x33d5
leaq 0xf(%rsp), %rdi
callq 0x34dc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x33fd
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34dc
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/debug_print.cpp
// Function: print_indentation()
void print_indentation() {
    if (config.log) {
        if (__call_depth > 0) {
            for (int i = 0; i != __call_depth - 1; ++i)
                printf("%c ", indent_char);
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1753f(%rip), %rax     # 0x1aa38
cmpb $0x1, (%rax)
jne 0x3532
cmpl $0x2, 0x1717b(%rip)     # 0x1a680
jl 0x3532
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xe07a(%rip), %rbx      # 0x1158d
movl 0x1716b(%rip), %esi     # 0x1a684
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl 0x17157(%rip), %eax     # 0x1a680
addl $-0x2, %eax
incl %ebp
cmpl %eax, %ebp
jne 0x3513
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/debug_print.cpp
// Function: debug_print(char const*, ...)
void debug_print(const char *fmt, ...) {
    if (config.log) {
        va_list args;
        va_start(args, fmt);
        print_indentation();
        vprintf(fmt, args);
        va_end(args);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x357e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
leaq 0x1749a(%rip), %rax     # 0x1aa38
cmpb $0x1, (%rax)
jne 0x35db
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
callq 0x34ef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/debug_print.cpp
// Function: debug_line(char const*, ...)
void debug_line(const char *fmt, ...) {
    if (config.log) {
        va_list args;
        va_start(args, fmt);
        debug_print(fmt, args);
        printf("\n");
        va_end(args);
    }
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x3628
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
leaq 0x173f0(%rip), %rax     # 0x1aa38
cmpb $0x1, (%rax)
jne 0x3683
leaq 0x20(%rsp), %rax
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
xorl %eax, %eax
callq 0x3539
movl $0xa, %edi
callq 0x2160
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/./error.cpp
// Function: void warning<char const*>(char const*)
static void warning(Args... args) {
    log(loc);
    bold_on();
    printf(" Warning: ");
    bold_off();
    log(args...);
    printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x16cae(%rip), %edx     # 0x1a690
leaq 0x17057(%rip), %rax     # 0x1aa40
movq (%rax), %rsi
leaq 0xe27f(%rip), %rdi      # 0x11c72
xorl %eax, %eax
callq 0x2030
leaq 0x17037(%rip), %r14     # 0x1aa38
cmpb $0x1, 0x1(%r14)
jne 0x3a16
leaq 0xe26c(%rip), %rdi      # 0x11c7b
xorl %eax, %eax
callq 0x2030
leaq 0xe263(%rip), %rdi      # 0x11c80
xorl %eax, %eax
callq 0x2030
cmpb $0x1, 0x1(%r14)
jne 0x3a39
leaq 0xdad3(%rip), %rdi      # 0x11505
xorl %eax, %eax
callq 0x2030
leaq 0xd974(%rip), %rdi      # 0x113b4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/./error.cpp
// Function: void fatal_error<char const*, char, char const*, int>(char const*, char, char const*, int)
static void fatal_error(Args... args) {
	printf("Fatal error: ");
	log(args...);
	printf("\n");
    exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0xda27(%rip), %rdi      # 0x11c8b
xorl %eax, %eax
callq 0x2030
leaq 0xd83a(%rip), %rdi      # 0x11aac
leaq 0xd84c(%rip), %rdx      # 0x11ac5
movl %ebp, %esi
movl %ebx, %ecx
callq 0x46e7
movl $0xa, %edi
callq 0x2160
movl $0x1, %edi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/lex.cpp
// Function: peek_token()
token_t peek_token() {
    // Save
    token_t save_token = token;
    location_t save_loc = loc;
    const char *save_input = input;
    next_token();
    // Save the new token to return it.
    token_t new_token = token;
    // Restore
    input = save_input;
    loc = save_loc;
    token = save_token;

    return new_token;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movups 0x163f4(%rip), %xmm0    # 0x1a698
movaps %xmm0, (%rsp)
movl 0x163e2(%rip), %ebx     # 0x1a690
movq 0x163f3(%rip), %r14     # 0x1a6a8
callq 0x3a62
movl 0x163d8(%rip), %eax     # 0x1a698
movq 0x163d9(%rip), %rdx     # 0x1a6a0
movq %r14, 0x163da(%rip)     # 0x1a6a8
movl %ebx, 0x163bc(%rip)     # 0x1a690
movaps (%rsp), %xmm0
movups %xmm0, 0x163b9(%rip)    # 0x1a698
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/lex.cpp
// Function: lexer_init(char const*, char const*)
void lexer_init(const char *input, const char *file) {
    int c;
    // Initialize charmap
    for (c = 0; c < 256; ++c) {
        if ('0' <= c && c <= '7') {
            charmap[c] |= OCT;
        }
        if (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) {
            charmap[c] |= HEX;
        }
        if ('0' <= c && c <= '9') {
            charmap[c] |= DEC;
            charmap[c] |= HEX;
        }
        
        switch(c) {
            case 0x9 ... 0xc:
            case 0x20:
                charmap[c] |= BLANK;
                break;
            case 0x21 ... 0x2f:
            case 0x3a ... 0x40:
            case 0x5b ... 0x5e:
            case 0x7b ... 0x7e:
                charmap[c] |= OTHER;
                break;
            case 'A' ... 'Z':
            case 'a' ... 'z':
            case '_':
                charmap[c] |= MIDCHAR;
                break;
        }
    }

    // Initialize digit_from_char
    for (c = '0'; c <= '9'; ++c) {
        digit_from_char[c] = c - '0';
    }
    for (c = 'a'; c <= 'f'; ++c) {
        digit_from_char[c] = c - 'a' + 10;
    }

    // Initialize location info
    loc.ln = 1;

    // Initialize the input
    init_input(input);
}

// Assembly:
xorl %eax, %eax
leaq 0x162df(%rip), %rcx     # 0x1a6b0
leaq 0xd3b4(%rip), %rdx      # 0x1178c
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
movl %eax, %r8d
andl $0xf8, %r8d
cmpl $0x30, %r8d
jne 0x43f6
orb $0x10, (%rax,%rcx)
movzbl %al, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x4442
movb $0x8, %r8b
btq %r9, %rsi
jae 0x4442
orb %r8b, (%rax,%rcx)
movzbl %al, %r8d
addl $-0x9, %r8d
cmpl $0x75, %r8d
ja 0x4435
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
movb $0x2, %r8b
jmp 0x4431
movb $0x20, %r8b
orb %r8b, (%rax,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x43e2
jmp 0x4456
leal -0x30(%rax), %r9d
movb $0xc, %r8b
cmpl $0x9, %r9d
jbe 0x440d
jmp 0x4411
movb $0x1, %r8b
jmp 0x4431
xorl %ecx, %ecx
leaq 0x16351(%rip), %rax     # 0x1a7b0
cmpq $0x9, %rcx
ja 0x4472
movw %cx, 0x60(%rax,%rcx,2)
leal 0x1(%rcx), %edx
movw %dx, 0x62(%rax,%rcx,2)
addq $0x2, %rcx
cmpq $0xa, %rcx
jne 0x445f
xorl %ecx, %ecx
cmpq $0x5, %rcx
ja 0x449a
leal 0xa(%rcx), %edx
movw %dx, 0xc2(%rax,%rcx,2)
leal 0xb(%rcx), %edx
movw %dx, 0xc4(%rax,%rcx,2)
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x447e
movq %rdi, 0x161fd(%rip)     # 0x1a6a8
movl $0x1, 0x161db(%rip)     # 0x1a690
jmp 0x3a62
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: emit(char const*, ...)
void emit(const char *fmt, ...) {
    if (config.codegen) {
        va_list args;
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
    }
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x47e7
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
leaq 0x16231(%rip), %rax     # 0x1aa38
cmpb $0x1, 0x4(%rax)
jne 0x4837
leaq 0x20(%rsp), %rax
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x2110
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_op_const(int, int, int)
llvalue_t llvm_op_const(int op, int val1, int val2) {
    int val = 0;
    switch (op) {
    case '+': val = val1 + val2; break;
    case '-': val = val1 - val2; break;
    case '*': val = val1 * val2; break;
    case '<': val = val1 < val2; break;
    case '&': val = val1 && val2; break;
    default: assert(0);
    }
    return const_llv(val, {});
}

// Assembly:
leal -0x26(%rsi), %eax
cmpl $0x7, %eax
ja 0x4884
leaq 0xd432(%rip), %rsi      # 0x11c9c
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
testl %edx, %edx
setne %al
testl %ecx, %ecx
setne %cl
andb %al, %cl
movzbl %cl, %ecx
jmp 0x48a1
cmpl $0x3c, %esi
jne 0x48bd
xorl %eax, %eax
cmpl %ecx, %edx
setl %al
movl %eax, %ecx
jmp 0x48a1
subl %ecx, %edx
movl %edx, %ecx
jmp 0x48a1
addl %edx, %ecx
jmp 0x48a1
imull %edx, %ecx
movl $0x1, (%rdi)
movl %ecx, 0x18(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xed5d(%rip), %rdi      # 0x13622
leaq 0xd635(%rip), %rsi      # 0x11f01
leaq 0xd637(%rip), %rcx      # 0x11f0a
movl $0x67, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_print_llvalue(llvalue_t, bool)
void cgen_print_llvalue(llvalue_t v, bool its_bool /* = false */) {
    if (v.kind == LLVALUE::CONST) {
        print_const_llvalue(v, its_bool);
    } else {
        emit("%%%ld", v.reg);
    }
}

// Assembly:
pushq %rax
leaq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x4902
movl 0x18(%rax), %esi
testb %dil, %dil
je 0x4915
cmpl $0x1, %esi
je 0x4924
testl %esi, %esi
jne 0x4933
leaq 0xdda2(%rip), %rdi      # 0x126a2
jmp 0x492b
movq 0x18(%rax), %rsi
leaq 0xdd35(%rip), %rdi      # 0x12642
xorl %eax, %eax
popq %rcx
jmp 0x47a5
leaq 0xe020(%rip), %rdi      # 0x1293c
xorl %eax, %eax
popq %rcx
jmp 0x47a5
leaq 0xdd7d(%rip), %rdi      # 0x126a8
xorl %eax, %eax
popq %rcx
jmp 0x47a5
leaq 0xdd73(%rip), %rdi      # 0x126ad
leaq 0xd5c0(%rip), %rsi      # 0x11f01
leaq 0xdd30(%rip), %rcx      # 0x12678
movl $0x74, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_print_stmt(llvalue_t)
void cgen_print_stmt(llvalue_t to_print) {
  print_codegen_indentation();
  emit("call void @print_int(i32 ");
  cgen_print_llvalue(to_print);
  emit(")\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x4, %ebp
leaq 0x20(%rsp), %r14
leaq 0xd6ef(%rip), %rbx      # 0x12056
movq %rbx, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x4967
leaq 0xd5b5(%rip), %rdi      # 0x11f31
xorl %eax, %eax
callq 0x47a5
movq 0x18(%r14), %rsi
cmpl $0x1, (%r14)
jne 0x499d
leaq 0xdfa8(%rip), %rdi      # 0x1293c
xorl %eax, %eax
callq 0x47a5
jmp 0x49ab
leaq 0xdc9e(%rip), %rdi      # 0x12642
xorl %eax, %eax
callq 0x47a5
leaq 0xf712(%rip), %rdi      # 0x140c4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x47a5
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_op(int, llvalue_t, llvalue_t)
llvalue_t llvm_op(int op, llvalue_t res1, llvalue_t res2) {
    if (res1.kind == LLVALUE::CONST && res2.kind == LLVALUE::CONST) {
        return llvm_op_const(op, res1.val, res2.val);
    }

    long lhs = gen_reg();
    print_codegen_indentation();
    emit("%%%ld = ", lhs);
    switch (op) {
    case '+': emit("add i32 "); break;
    case '-': emit("sub i32 "); break;
    case '*': emit("mul i32 "); break;
    case '<': emit("icmp slt i32 "); break;
    case '&': emit("and i1 "); break;
    default: assert(0);
    }
    cgen_print_llvalue(res1);
    emit(", ");
    cgen_print_llvalue(res2);
    emit("\n");
    return register_llv(lhs, {});
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl (%rdi), %r14d
movl %r14d, %eax
xorl $0x1, %eax
movl (%rsi), %edx
movl %edx, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
jne 0x4a02
movl 0x18(%rdi), %edx
movl 0x18(%rsi), %ecx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x485b
jmp 0x4b2c
movl %edx, 0x4(%rsp)
movq 0x1601b(%rip), %rax     # 0x1aa28
movq %rax, %rbp
incq %rax
movq %rax, 0x1600e(%rip)     # 0x1aa28
movl $0x4, %r13d
leaq 0xd62f(%rip), %r12      # 0x12056
movq %r12, %rdi
xorl %eax, %eax
callq 0x47a5
decl %r13d
jne 0x4a27
leaq 0xd50e(%rip), %rdi      # 0x11f4b
movq %rbp, %rsi
xorl %eax, %eax
callq 0x47a5
leal -0x26(%r15), %eax
cmpl $0x7, %eax
ja 0x4a69
leaq 0xd265(%rip), %rcx      # 0x11cbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd516(%rip), %rdi      # 0x11f7d
jmp 0x4a95
cmpl $0x3c, %r15d
jne 0x4b3e
leaq 0xd4f5(%rip), %rdi      # 0x11f6f
jmp 0x4a95
leaq 0xd4d1(%rip), %rdi      # 0x11f54
jmp 0x4a95
leaq 0xd4d1(%rip), %rdi      # 0x11f5d
jmp 0x4a95
leaq 0xd4d1(%rip), %rdi      # 0x11f66
xorl %eax, %eax
callq 0x47a5
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %rsi
cmpl $0x1, %r14d
jne 0x4abb
leaq 0xde8a(%rip), %rdi      # 0x1293c
xorl %eax, %eax
callq 0x47a5
jmp 0x4ac9
leaq 0xdb80(%rip), %rdi      # 0x12642
xorl %eax, %eax
callq 0x47a5
leaq 0xf260(%rip), %rdi      # 0x13d30
xorl %eax, %eax
callq 0x47a5
leaq 0x60(%rsp), %rax
movq 0x18(%rax), %rsi
cmpl $0x1, 0x4(%rsp)
jne 0x4af7
leaq 0xde4e(%rip), %rdi      # 0x1293c
xorl %eax, %eax
callq 0x47a5
jmp 0x4b05
leaq 0xdb44(%rip), %rdi      # 0x12642
xorl %eax, %eax
callq 0x47a5
leaq 0xd988(%rip), %rdi      # 0x12494
xorl %eax, %eax
callq 0x47a5
movl $0x2, (%rbx)
movq %rbp, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeadd(%rip), %rdi      # 0x13622
leaq 0xd3b5(%rip), %rsi      # 0x11f01
leaq 0xd432(%rip), %rcx      # 0x11f85
movl $0x9f, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: emit_vmethod_signature(Type*, Method*)
void emit_vmethod_signature(Type *base_obj_ty, Method *method) {
    cgen_print_lltype(method->ret_type);
    // Print "this" pointer
    emit(" (i8*");
    //cgen_print_lltype(base_obj_ty);
    if (method->param_len) {
      emit(", ");
    }
    for (size_t i = 0; i != method->param_len; ++i) {
        Local *param = method->locals[i];
        cgen_print_lltype(param->type);
        if (i != method->param_len - 1) {
            emit(", ");
        }
    }
    emit(")*");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x4b5d
leaq 0xd427(%rip), %rdi      # 0x11fdd
xorl %eax, %eax
callq 0x47a5
cmpq $0x0, 0x10(%rbx)
je 0x4c17
leaq 0xf165(%rip), %rdi      # 0x13d30
xorl %eax, %eax
callq 0x47a5
cmpq $0x0, 0x10(%rbx)
je 0x4c17
leaq 0xf150(%rip), %r14      # 0x13d30
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
callq 0x4b5d
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r15
je 0x4c0f
movq %r14, %rdi
xorl %eax, %eax
callq 0x47a5
movq 0x10(%rbx), %rax
incq %r15
cmpq %rax, %r15
jne 0x4be3
leaq 0xd3c5(%rip), %rdi      # 0x11fe3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x47a5
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_get_field_ptr(Local*)
llvalue_t cgen_get_field_ptr(Local *field) {
    assert(field->kind == (int)LOCAL_KIND::FIELD);
    llvalue_t reg0 = register_llv(0, {});
    llvalue_t ptr = reg0;
    int account_for_vptr = field->offset + 8;
    ptr = llvm_getelementptr_i8(reg0, account_for_vptr);
    return llvm_bitcast_from_i8p(field->type, ptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x2, 0x38(%rsi)
jne 0x4ec9
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r13
movq 0x15be4(%rip), %r15     # 0x1aa28
leaq 0x1(%r15), %rax
movq %rax, 0x15bd9(%rip)     # 0x1aa28
movl $0x4, %ebp
leaq 0xd1fb(%rip), %r12      # 0x12056
movq %r12, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x4e5b
addl $0x8, %r13d
movslq %r13d, %rcx
leaq 0xd474(%rip), %rdi      # 0x122eb
movq %r15, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x47a5
movq 0x8(%r14), %rsi
movl $0x2, 0x28(%rsp)
movl $0x0, 0x38(%rsp)
movq %r15, 0x40(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x4f65
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd21d(%rip), %rdi      # 0x120ed
leaq 0xd02a(%rip), %rsi      # 0x11f01
leaq 0xd235(%rip), %rcx      # 0x12113
movl $0xee, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_getelementptr_i8(llvalue_t, unsigned long)
llvalue_t llvm_getelementptr_i8(llvalue_t ptr, size_t offset) {
    llvalue_t v;
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    emit("%%%ld = getelementptr inbounds i8, i8* %%%ld, i32 %zd\n", v.reg, ptr.reg, offset);
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movl $0x0, 0x10(%rdi)
movq 0x15b1c(%rip), %r15     # 0x1aa28
leaq 0x1(%r15), %rax
movq %rax, 0x15b11(%rip)     # 0x1aa28
movq %r15, 0x18(%rdi)
movl $0x2, (%rdi)
movl $0x4, %ebp
leaq 0xd129(%rip), %r12      # 0x12056
movq %r12, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x4f2d
movq 0x18(%r13), %rdx
leaq 0xd3a5(%rip), %rdi      # 0x122eb
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x47a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_bitcast_i8p_to_i8ppp(llvalue_t)
llvalue_t llvm_bitcast_i8p_to_i8ppp(llvalue_t i8p) {
  llvalue_t i8ppp = register_llv(gen_reg(), {});
  print_codegen_indentation();
  emit("%%%ld = bitcast i8* %%%ld to i8***\n", i8ppp.reg, i8p.reg);
  return i8ppp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq 0x159d9(%rip), %r14     # 0x1aa28
leaq 0x1(%r14), %rax
movq %rax, 0x159ce(%rip)     # 0x1aa28
movl $0x2, (%rdi)
movq %r14, 0x18(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x4, %ebp
leaq 0xcfd7(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x507f
movq 0x18(%r12), %rdx
leaq 0xd178(%rip), %rdi      # 0x12211
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_store_vptr(llvalue_t, IdType*)
void cgen_store_vptr(llvalue_t i8ppp, IdType *type) {
  llvalue_t i8pp_to_vtable = register_llv(gen_reg(), {});
  print_codegen_indentation();
  emit("%%%ld = bitcast [%ld x i8*]* @.%s to i8**\n", i8pp_to_vtable.reg,
       type->vmethods_len, type->id);
  print_codegen_indentation();
  emit("store i8** %%%ld, i8*** %%%ld\n", i8pp_to_vtable.reg, i8ppp.reg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq 0x15962(%rip), %rbx     # 0x1aa28
leaq 0x1(%rbx), %rax
movq %rax, 0x15957(%rip)     # 0x1aa28
movl $0x4, %ebp
leaq 0xcf79(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x50dd
movq 0x8(%r14), %rcx
movq 0x70(%r14), %rdx
leaq 0xd13b(%rip), %rdi      # 0x12235
movq %rbx, %rsi
xorl %eax, %eax
callq 0x47a5
movl $0x4, %ebp
leaq 0xcf46(%rip), %r14      # 0x12056
movq %r14, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x5110
movq 0x18(%r12), %rdx
leaq 0xd136(%rip), %rdi      # 0x12260
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x47a5
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_getelementptr_i32(llvalue_t, llvalue_t)
llvalue_t llvm_getelementptr_i32(llvalue_t ptr, llvalue_t index) {
    assert(ptr.kind == LLVALUE::REG);
    llvalue_t v;
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    emit("%%%ld = getelementptr inbounds i32, i32* %%%ld, i32 ", v.reg, ptr.reg);
    cgen_print_llvalue(index);
    emit("\n");
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, 0x40(%rsp)
jne 0x51fb
movq %rdi, %rbx
leaq 0x60(%rsp), %r12
leaq 0x40(%rsp), %r13
movl $0x0, 0x10(%rdi)
movq 0x158bb(%rip), %r14     # 0x1aa28
leaq 0x1(%r14), %rax
movq %rax, 0x158b0(%rip)     # 0x1aa28
movq %r14, 0x18(%rdi)
movl $0x2, (%rdi)
movl $0x4, %ebp
leaq 0xcec8(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x518e
movq 0x18(%r13), %rdx
leaq 0xd10f(%rip), %rdi      # 0x122b6
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
movq 0x18(%r12), %rsi
cmpl $0x1, (%r12)
jne 0x51cd
leaq 0xd778(%rip), %rdi      # 0x1293c
xorl %eax, %eax
callq 0x47a5
jmp 0x51db
leaq 0xd46e(%rip), %rdi      # 0x12642
xorl %eax, %eax
callq 0x47a5
leaq 0xd2b2(%rip), %rdi      # 0x12494
xorl %eax, %eax
callq 0x47a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcf37(%rip), %rdi      # 0x12139
leaq 0xccf8(%rip), %rsi      # 0x11f01
leaq 0xd06f(%rip), %rcx      # 0x1227f
movl $0x125, %edx            # imm = 0x125
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_load(Type*, llvalue_t)
llvalue_t llvm_load(Type *type, llvalue_t ptr) {
    assert(ptr.kind == LLVALUE::REG);
    llvalue_t v;
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    switch (type->kind) {
    case TY::BOOL:
    {
        emit("%%%ld = load i1, i1* %%%ld\n", v.reg, ptr.reg);
    } break;
    case TY::INT:
    {
        emit("%%%ld = load i32, i32* %%%ld, align 4\n", v.reg, ptr.reg);
    } break;
    case TY::ARR:
    {
        emit("%%%ld = load i32*, i32** %%%ld, align 8\n", v.reg, ptr.reg);
    } break;
    case TY::ID:
    {
        emit("%%%ld = load i8*, i8** %%%ld\n", v.reg, ptr.reg);
    } break;
    default: assert(0);
    }
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, 0x40(%rsp)
jne 0x52b3
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movl $0x0, 0x10(%rdi)
movq 0x157df(%rip), %r14     # 0x1aa28
leaq 0x1(%r14), %rax
movq %rax, 0x157d4(%rip)     # 0x1aa28
movq %r14, 0x18(%rdi)
movl $0x2, (%rdi)
movl $0x4, %ebp
leaq 0xcdec(%rip), %r12      # 0x12056
movq %r12, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x526a
movl 0x4(%r15), %eax
decl %eax
cmpl $0x4, %eax
jae 0x52d2
movl %eax, %eax
leaq 0xca80(%rip), %rcx      # 0x11d0c
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq 0x18(%r13), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce7f(%rip), %rdi      # 0x12139
leaq 0xcc40(%rip), %rsi      # 0x11f01
leaq 0xd05a(%rip), %rcx      # 0x12322
movl $0x13a, %edx            # imm = 0x13A
callq 0x20b0
leaq 0xe349(%rip), %rdi      # 0x13622
leaq 0xcc21(%rip), %rsi      # 0x11f01
leaq 0xd03b(%rip), %rcx      # 0x12322
movl $0x150, %edx            # imm = 0x150
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: not_llvalue(llvalue_t)
llvalue_t not_llvalue(llvalue_t v) {
    assert(v.kind == LLVALUE::REG);
    long reg = gen_reg();
    print_codegen_indentation();
    emit("%%%ld = icmp eq i1 %%%ld, 0\n", reg, v.reg);
    v.reg = reg;
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, 0x30(%rsp)
jne 0x5375
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq 0x15719(%rip), %r14     # 0x1aa28
leaq 0x1(%r14), %rax
movq %rax, 0x1570e(%rip)     # 0x1aa28
movl $0x4, %ebp
leaq 0xcd30(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x5326
movq 0x18(%r12), %rdx
leaq 0xd0ad(%rip), %rdi      # 0x123ed
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
movq %r14, 0x18(%r12)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r12), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd039(%rip), %rdi      # 0x123b5
leaq 0xcb7e(%rip), %rsi      # 0x11f01
leaq 0xd042(%rip), %rcx      # 0x123cc
movl $0x156, %edx            # imm = 0x156
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_calloc(llvalue_t)
llvalue_t llvm_calloc(llvalue_t sz) {
    llvalue_t v = register_llv(gen_reg(), {});
    print_codegen_indentation();
    if (sz.kind == LLVALUE::CONST) {
        emit("%%%ld = call noalias i8* @calloc(i32 1, i32 %d)\n", v.reg, sz.val);
    } else {
        emit("%%%ld = call noalias i8* @calloc(i32 1, i32 %%%ld)\n", v.reg, sz.reg);
    }
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq 0x1567d(%rip), %r14     # 0x1aa28
leaq 0x1(%r14), %rax
movq %rax, 0x15672(%rip)     # 0x1aa28
movl $0x2, (%rdi)
movq %r14, 0x18(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x4, %ebp
leaq 0xcc7b(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x53db
cmpl $0x1, (%r12)
jne 0x5408
movl 0x18(%r12), %edx
leaq 0xd00e(%rip), %rdi      # 0x1240a
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
jmp 0x541e
movq 0x18(%r12), %rdx
leaq 0xd027(%rip), %rdi      # 0x1243b
movq %r14, %rsi
xorl %eax, %eax
callq 0x47a5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_branch_cond(llvalue_t, llvm_label_t, llvm_label_t)
void llvm_branch_cond(llvalue_t cond, llvm_label_t l1, llvm_label_t l2) {
    print_codegen_indentation();
    emit("br i1 ");
    cgen_print_llvalue(cond);
    emit(", label %%%s, label %%%s\n\n", l1.lbl, l2.lbl);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %ebp
leaq 0x30(%rsp), %r12
leaq 0xcbef(%rip), %r15      # 0x12056
movq %r15, %rdi
xorl %eax, %eax
callq 0x47a5
decl %ebp
jne 0x5467
leaq 0xcff8(%rip), %rdi      # 0x12474
xorl %eax, %eax
callq 0x47a5
movq 0x18(%r12), %rsi
cmpl $0x1, (%r12)
jne 0x549f
leaq 0xd4a6(%rip), %rdi      # 0x1293c
xorl %eax, %eax
callq 0x47a5
jmp 0x54ad
leaq 0xd19c(%rip), %rdi      # 0x12642
xorl %eax, %eax
callq 0x47a5
leaq 0xcfc7(%rip), %rdi      # 0x1247b
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x47a5