LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: olly-larkin[P]mips-parser/src/instructionList.cpp
// Function: regMemSeperator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, int&)
bool regMemSeperator(std::string str, int& offset, int& reg) {
    std::size_t index;
    offset = std::stoi(str, &index, 0);
    if (index == 0 || str[index] != '(')
        return false;
    str.pop_back();
    std::string regStr;
    for(int i = index+1; i < str.size(); ++i)
        regStr += str[i];
    if (regMap.find(regStr) == regMap.end())
        return false;
    reg = regMap[regStr];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x7450
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0xdc6a
movq -0x80(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3470
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0xdc73
movb $0x0, -0x1(%rbp)
jmp 0xdd95
movq -0x80(%rbp), %rdi
callq 0x32d0
leaq -0x48(%rbp), %rdi
callq 0x3340
movq -0x28(%rbp), %rax
addq $0x1, %rax
movl %eax, -0x4c(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x4c(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x31e0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0xdd05
movq -0x80(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3470
movq %rax, -0x90(%rbp)
jmp 0xdcc9
movq -0x90(%rbp), %rax
movsbl (%rax), %esi
leaq -0x48(%rbp), %rdi
callq 0x31b0
jmp 0xdcde
jmp 0xdce0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xdc90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
jmp 0xdda3
leaq 0xd5c4(%rip), %rdi      # 0x1b2d0
leaq -0x48(%rbp), %rsi
callq 0x7c70
movq %rax, -0x98(%rbp)
jmp 0xdd1e
movq -0x98(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0xd5a0(%rip), %rdi      # 0x1b2d0
callq 0x7ca0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7c40
testb $0x1, %al
jne 0xdd4c
jmp 0xdd59
movb $0x0, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0xdd8c
leaq 0xd570(%rip), %rdi      # 0x1b2d0
leaq -0x48(%rbp), %rsi
callq 0x74c0
movq %rax, -0xa0(%rbp)
jmp 0xdd72
movq -0xa0(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: baziotis[P]minijava-cpp/alloc.cpp
// Function: allocate_zero(unsigned long, MEM)
void *allocate_zero(size_t n, MEM ar) {
    void *mem = allocate(n, ar);
    assert(mem);
    // Zero it
    memset(mem, 0, n);
    return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2340
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2598
jmp 0x25b7
leaq 0x16abf(%rip), %rdi     # 0x1905e
leaq 0x16a5e(%rip), %rsi     # 0x19004
movl $0x60, %edx
leaq 0x16ab0(%rip), %rcx     # 0x19062
callq 0x20d0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x20b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x21b18(%rip), %rax     # 0x24100
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
jne 0x25f4
jmp 0x2663
movq 0x2200d(%rip), %rcx     # 0x24608
movslq -0x8(%rbp), %rdx
leaq 0x21afa(%rip), %rax     # 0x24100
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movslq -0x8(%rbp), %rcx
leaq 0x21f48(%rip), %rax     # 0x24560
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x21fdf(%rip)     # 0x24608
movslq -0x8(%rbp), %rcx
leaq 0x21f2c(%rip), %rax     # 0x24560
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movslq -0x8(%rbp), %rax
leaq 0x21f13(%rip), %rdx     # 0x24560
imulq $0x18, %rax, %rax
addq %rax, %rdx
movslq -0x8(%rbp), %rcx
leaq 0x21aa1(%rip), %rax     # 0x24100
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x16af1(%rip), %rax     # 0x1916f
movq %rax, 0x21f93(%rip)     # 0x24618
leaq 0x16af1(%rip), %rax     # 0x1917d
movq %rax, 0x21f8d(%rip)     # 0x24620
leaq 0x16af1(%rip), %rax     # 0x1918b
movq %rax, 0x21f87(%rip)     # 0x24628
leaq 0x16af4(%rip), %rax     # 0x1919c
movq %rax, 0x21f81(%rip)     # 0x24630
leaq 0x16af8(%rip), %rax     # 0x191ae
movq %rax, 0x21f7b(%rip)     # 0x24638
leaq 0x16afc(%rip), %rax     # 0x191c0
movq %rax, 0x21f75(%rip)     # 0x24640
leaq 0x16afa(%rip), %rax     # 0x191cc
movq %rax, 0x21f6f(%rip)     # 0x24648
leaq 0x16af8(%rip), %rax     # 0x191d8
movq %rax, 0x21f69(%rip)     # 0x24650
leaq 0x16af6(%rip), %rax     # 0x191e4
movq %rax, 0x21f63(%rip)     # 0x24658
leaq 0x16af6(%rip), %rax     # 0x191f2
movq %rax, 0x21f5d(%rip)     # 0x24660
leaq 0x16af3(%rip), %rax     # 0x191fd
movq %rax, 0x21f57(%rip)     # 0x24668
leaq 0x16af4(%rip), %rax     # 0x1920c
movq %rax, 0x21f51(%rip)     # 0x24670
leaq 0x16af2(%rip), %rax     # 0x19218
movq %rax, 0x21f4b(%rip)     # 0x24678
leaq 0x16af3(%rip), %rax     # 0x19227
movq %rax, 0x21f45(%rip)     # 0x24680
leaq 0x16aea(%rip), %rax     # 0x1922c
movq %rax, 0x21f3f(%rip)     # 0x24688
leaq 0x16af1(%rip), %rax     # 0x19241
movq %rax, 0x21eb9(%rip)     # 0x24610
movslq -0x4(%rbp), %rcx
leaq 0x21eae(%rip), %rax     # 0x24610
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x167ab(%rip), %rdi     # 0x1930f
xorl %eax, %eax
callq 0x3f10
jmp 0x2b6d
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x39f0
movq %rax, -0x50(%rbp)
jmp 0x2b88
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a10
movq %rax, -0x58(%rbp)
jmp 0x2b9f
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x2bf2
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x2bcb
jmp 0x2bcd
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x2ba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3dd0
jmp 0x2c11
leaq 0x19083(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x2c02
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x21c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x166db(%rip), %rdi     # 0x1931f
xorl %eax, %eax
callq 0x3f10
jmp 0x2c4d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x166d8(%rip), %rdi     # 0x19334
xorl %eax, %eax
callq 0x3e60
jmp 0x2c65
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2770
jmp 0x2c74
leaq 0x19001(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x2c84
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x16662(%rip), %rdi     # 0x19346
xorl %eax, %eax
callq 0x3f10
jmp 0x2ced
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x16638(%rip), %rdi     # 0x19334
xorl %eax, %eax
callq 0x3e60
jmp 0x2d05
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2770
jmp 0x2d14
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2770
jmp 0x2d23
leaq 0x18f52(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x2d33
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x165dc(%rip), %rdi     # 0x19360
xorl %eax, %eax
callq 0x3f10
jmp 0x2d8d
leaq 0x165d9(%rip), %rdi     # 0x1936d
xorl %eax, %eax
callq 0x3e60
jmp 0x2d9d
leaq -0x1d(%rbp), %rdi
callq 0x3da0
jmp 0x2da8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2770
jmp 0x2db7
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
leaq 0x165b0(%rip), %rdi     # 0x19377
xorl %eax, %eax
callq 0x3e60
jmp 0x2dd0
leaq -0x1e(%rbp), %rdi
callq 0x3da0
jmp 0x2ddb
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x2dee
leaq -0x1e(%rbp), %rdi
callq 0x3dd0
leaq 0x16583(%rip), %rdi     # 0x19381
xorl %eax, %eax
callq 0x3e60
jmp 0x2e07
leaq -0x1f(%rbp), %rdi
callq 0x3da0
jmp 0x2e12
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x2e25
leaq -0x1f(%rbp), %rdi
callq 0x3dd0
leaq 0x18e47(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x2e3e
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
jmp 0x2e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x3dd0
jmp 0x2e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x3dd0
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x164b7(%rip), %rdi     # 0x1938b
xorl %eax, %eax
callq 0x3f10
jmp 0x2edd
leaq 0x16489(%rip), %rdi     # 0x1936d
xorl %eax, %eax
callq 0x3e60
jmp 0x2eed
leaq -0x1d(%rbp), %rdi
callq 0x3da0
jmp 0x2ef8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2770
jmp 0x2f07
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
leaq 0x16484(%rip), %rdi     # 0x1939b
xorl %eax, %eax
callq 0x3e60
jmp 0x2f20
leaq -0x1e(%rbp), %rdi
callq 0x3da0
jmp 0x2f2b
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x2f3e
leaq -0x1e(%rbp), %rdi
callq 0x3dd0
leaq 0x18d2e(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x2f57
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2fa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
jmp 0x2fa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x3dd0
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
leaq 0x163c1(%rip), %rdi     # 0x193a5
xorl %eax, %eax
callq 0x3f10
jmp 0x2fed
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2770
jmp 0x2ffc
leaq 0x18c79(%rip), %rdi     # 0x1bc7c
xorl %eax, %eax
callq 0x3f10
jmp 0x300c
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x30c4
movq -0x18(%rbp), %rax
leaq 0x16059(%rip), %rcx     # 0x190c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1633e(%rip), %rdi     # 0x193b5
movb $0x0, %al
callq 0x2030
jmp 0x30e3
leaq 0x16349(%rip), %rdi     # 0x193d0
movb $0x0, %al
callq 0x2030
jmp 0x30e3
leaq 0x1633f(%rip), %rdi     # 0x193d6
movb $0x0, %al
callq 0x2030
jmp 0x30e3
leaq 0x16333(%rip), %rdi     # 0x193da
movb $0x0, %al
callq 0x2030
jmp 0x30e3
movq -0x8(%rbp), %rsi
leaq 0x16327(%rip), %rdi     # 0x193e2
movb $0x0, %al
callq 0x2030
jmp 0x30e3
leaq 0x188b7(%rip), %rdi     # 0x1b982
leaq 0x161fa(%rip), %rsi     # 0x192cc
movl $0xcd, %edx
leaq 0x16310(%rip), %rcx     # 0x193ee
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/ast.cpp
// Function: typespec_name(Typespec)
const char *typespec_name(Typespec tspec) {
    switch (tspec.kind) {
    case TYSPEC::UNDEFINED: return "Undefined Typespec (Error)";
    case TYSPEC::ARR: return "int[]";
    case TYSPEC::INT: return "int";
    case TYSPEC::BOOL: return "boolean";
    case TYSPEC::ID: return "Id Type";
    default: assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x3161
movq -0x20(%rbp), %rax
leaq 0x15fbd(%rip), %rcx     # 0x190d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1628e(%rip), %rax     # 0x193b5
movq %rax, -0x8(%rbp)
jmp 0x3180
leaq 0x1629c(%rip), %rax     # 0x193d0
movq %rax, -0x8(%rbp)
jmp 0x3180
leaq 0x16295(%rip), %rax     # 0x193d6
movq %rax, -0x8(%rbp)
jmp 0x3180
leaq 0x1628c(%rip), %rax     # 0x193da
movq %rax, -0x8(%rbp)
jmp 0x3180
leaq 0x162b1(%rip), %rax     # 0x1940c
movq %rax, -0x8(%rbp)
jmp 0x3180
leaq 0x1881a(%rip), %rdi     # 0x1b982
leaq 0x1615d(%rip), %rsi     # 0x192cc
movl $0xd8, %edx
leaq 0x16299(%rip), %rcx     # 0x19414
callq 0x20d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x15dc5(%rip), %rdi     # 0x194f4
xorl %eax, %eax
callq 0x3e60
jmp 0x3738
leaq -0x1d(%rbp), %rdi
callq 0x3da0
jmp 0x3743
leaq 0x15db9(%rip), %rdi     # 0x19503
xorl %eax, %eax
callq 0x3e60
jmp 0x3753
movq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a70
movq %rax, -0x78(%rbp)
jmp 0x376e
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a90
movq %rax, -0x80(%rbp)
jmp 0x3785
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x37e8
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x33f0
jmp 0x37ad
jmp 0x37af
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x378d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x38c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
jmp 0x38c8
leaq -0x1d(%rbp), %rdi
callq 0x3dd0
leaq -0x41(%rbp), %rdi
callq 0x3da0
jmp 0x37fc
leaq 0x15d1c(%rip), %rdi     # 0x1951f
xorl %eax, %eax
callq 0x3e60
jmp 0x380c
movq -0x70(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x39f0
movq %rax, -0x88(%rbp)
jmp 0x382a
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3a10
movq %rax, -0x90(%rbp)
jmp 0x3847
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0x389d
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x3876
jmp 0x3878
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
jmp 0x3852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3dd0
jmp 0x38c8
leaq -0x41(%rbp), %rdi
callq 0x3dd0
leaq 0x18b89(%rip), %rdi     # 0x1c436
xorl %eax, %eax
callq 0x3e60
jmp 0x38b6
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x90, %rsp
popq %rbp
retq
leaq -0x9(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x21c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3da0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x3700
jmp 0x390c
movq -0x48(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3b10
movq %rax, -0x50(%rbp)
jmp 0x3927
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3b30
movq %rax, -0x58(%rbp)
jmp 0x393e
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x398d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3190
jmp 0x3966
jmp 0x3968
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x3946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x3dd0
jmp 0x399c
leaq -0x9(%rbp), %rdi
callq 0x3dd0
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x20c39(%rip), %rax     # 0x24a48
testb $0x1, (%rax)
je 0x3e57
cmpl $0x0, 0x20875(%rip)     # 0x24690
jle 0x3e55
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl 0x20863(%rip), %ecx     # 0x24690
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x3e53
movl 0x2085a(%rip), %esi     # 0x24694
leaq 0x15783(%rip), %rdi     # 0x195c4
movb $0x0, %al
callq 0x2030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e24
jmp 0x3e55
jmp 0x3e57
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x3e95
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x20b85(%rip), %rax     # 0x24a48
testb $0x1, (%rax)
je 0x3f02
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
callq 0x3e00
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2130
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x3f45
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x20ad5(%rip), %rax     # 0x24a48
testb $0x1, (%rax)
je 0x3fbd
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movb $0x0, %al
callq 0x3e60
leaq 0x16792(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x2030
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x2039e(%rip), %eax     # 0x246a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x5790
callq 0x57f0
leaq 0x15ba0(%rip), %rdi     # 0x19eb9
movb $0x0, %al
callq 0x2030
callq 0x5850
movq -0x8(%rbp), %rdi
callq 0x5820
leaq 0x1640f(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x14e54(%rip), %rdi     # 0x19ec4
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movsbl %al, %esi
callq 0x5920
leaq 0x156b0(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x2150
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movups 0x1f5e9(%rip), %xmm0    # 0x246a8
movaps %xmm0, -0x20(%rbp)
movl 0x1f5d7(%rip), %eax     # 0x246a0
movl %eax, -0x24(%rbp)
movq 0x1f5e5(%rip), %rax     # 0x246b8
movq %rax, -0x30(%rbp)
callq 0x4370
movups 0x1f5c5(%rip), %xmm0    # 0x246a8
movaps %xmm0, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x1f5c6(%rip)     # 0x246b8
movl -0x24(%rbp), %eax
movl %eax, 0x1f5a5(%rip)     # 0x246a0
movaps -0x20(%rbp), %xmm0
movups %xmm0, 0x1f5a2(%rip)    # 0x246a8
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/./error.cpp
// Function: void syntax_error_no_ln<char const*>(char const*)
static void syntax_error_no_ln(Args... args) {
    log(loc);
    red_on();
    bold_on();
    log(" Syntax Error: ");
    bold_off();
    red_off();
    log(args...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x1ef4e(%rip), %eax     # 0x246a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x5790
callq 0x57c0
callq 0x57f0
leaq 0x1472a(%rip), %rdi     # 0x19e98
callq 0x5820
callq 0x5850
callq 0x5880
movq -0x8(%rbp), %rdi
callq 0x5820
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: register_llv(long, LLType)
llvalue_t register_llv(long r, LLType type) {
    llvalue_t llval;
    llval.kind = LLVALUE::REG;
    llval.reg = r;
    llval.ty = type;
    return llval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x7840
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x2, (%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: const_llv(int, LLType)
llvalue_t const_llv(int v, LLType type) {
    llvalue_t llval;
    llval.kind = LLVALUE::CONST;
    llval.val = v;
    llval.ty = type;
    return llval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x8(%rbp)
movl %esi, -0x14(%rbp)
callq 0x7840
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x1, (%rdi)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5ba5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x1ee75(%rip), %rax     # 0x24a48
testb $0x1, 0x4(%rax)
je 0x5c0e
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2130
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $-0x26, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x16, %eax
ja 0x5cec
movq -0x28(%rbp), %rax
leaq 0x14248(%rip), %rcx     # 0x19ed4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x5d0b
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x5d0b
movl -0x8(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x5d0b
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x5d0b
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x39(%rbp)
je 0x5cdf
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x5d0b
leaq 0x15c8f(%rip), %rdi     # 0x1b982
leaq 0x144b7(%rip), %rsi     # 0x1a1b1
movl $0x67, %edx
leaq 0x144b4(%rip), %rcx     # 0x1a1ba
callq 0x20d0
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %esi
movq $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq 0x5b20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %cl
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x1(%rbp)
cmpl $0x1, (%rax)
jne 0x5db6
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movb -0x1(%rbp), %al
leaq -0x28(%rbp), %rcx
andb $0x1, %al
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movzbl %al, %edi
callq 0x5de0
jmp 0x5dcc
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x14b5f(%rip), %rdi     # 0x1a924
movb $0x0, %al
callq 0x5b70
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: print_const_llvalue(llvalue_t, bool)
static void print_const_llvalue(llvalue_t v, bool its_bool) {
    assert(v.kind == LLVALUE::CONST);
    if (its_bool) {
        if (v.val == 0) {
            emit("false");
        } else if (v.val == 1) {
            emit("true");
        } else {
            assert(0 && "Boolean llvalues can only have value 0 or 1");
        }
    } else {
        emit("%d", v.val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %cl
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x1(%rbp)
cmpl $0x1, (%rax)
jne 0x5e00
jmp 0x5e1f
leaq 0x14b53(%rip), %rdi     # 0x1a95a
leaq 0x143a3(%rip), %rsi     # 0x1a1b1
movl $0x6d, %edx
leaq 0x14b59(%rip), %rcx     # 0x1a973
callq 0x20d0
testb $0x1, -0x1(%rbp)
je 0x5e7c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x5e3f
leaq 0x14b67(%rip), %rdi     # 0x1a99d
movb $0x0, %al
callq 0x5b70
jmp 0x5e7a
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x5e59
leaq 0x14b53(%rip), %rdi     # 0x1a9a3
movb $0x0, %al
callq 0x5b70
jmp 0x5e78
leaq 0x14b48(%rip), %rdi     # 0x1a9a8
leaq 0x1434a(%rip), %rsi     # 0x1a1b1
movl $0x74, %edx
leaq 0x14b00(%rip), %rcx     # 0x1a973
callq 0x20d0
jmp 0x5e7a
jmp 0x5e91
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x14e8e(%rip), %rdi     # 0x1ad18
movb $0x0, %al
callq 0x5b70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5f30
leaq 0x14325(%rip), %rdi     # 0x1a1e1
movb $0x0, %al
callq 0x5b70
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x1651c(%rip), %rdi     # 0x1c436
movb $0x0, %al
callq 0x5b70
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_print_lltype(Type*)
void cgen_print_lltype(Type *type) {
    switch (type->kind) {
    case TY::BOOL: emit("i1"); break;
    case TY::INT: emit("i32"); break;
    case TY::ARR: emit("i32*"); break;
    case TY::ID:
    {
        emit("i8*");
    } break;
    default: assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x61e4
movq -0x10(%rbp), %rax
leaq 0x13df1(%rip), %rcx     # 0x19f8c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x140b7(%rip), %rdi     # 0x1a262
movb $0x0, %al
callq 0x5b70
jmp 0x6203
leaq 0x140aa(%rip), %rdi     # 0x1a265
movb $0x0, %al
callq 0x5b70
jmp 0x6203
leaq 0x1409e(%rip), %rdi     # 0x1a269
movb $0x0, %al
callq 0x5b70
jmp 0x6203
leaq 0x140b4(%rip), %rdi     # 0x1a28f
movb $0x0, %al
callq 0x5b70
jmp 0x6203
leaq 0x15797(%rip), %rdi     # 0x1b982
leaq 0x13fbf(%rip), %rsi     # 0x1a1b1
movl $0xb1, %edx
leaq 0x14070(%rip), %rcx     # 0x1a26e
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6170
leaq 0x14059(%rip), %rdi     # 0x1a28d
movb $0x0, %al
callq 0x5b70
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6254
leaq 0x15e55(%rip), %rdi     # 0x1c0a2
movb $0x0, %al
callq 0x5b70
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x62c2
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x7870
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6170
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x62b2
leaq 0x15df7(%rip), %rdi     # 0x1c0a2
movb $0x0, %al
callq 0x5b70
jmp 0x62b4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x625c
leaq 0x13fca(%rip), %rdi     # 0x1a293
movb $0x0, %al
callq 0x5b70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, -0xc8(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x38(%rax), %eax
cmpl $0x2, %eax
jne 0x648c
jmp 0x64ab
leaq 0x13f0a(%rip), %rdi     # 0x1a39d
leaq 0x13d17(%rip), %rsi     # 0x1a1b1
movl $0xee, %edx
leaq 0x13f1d(%rip), %rcx     # 0x1a3c3
callq 0x20d0
movq $0x0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %ecx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ad0
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movslq -0x5c(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x6600
movq -0xd0(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x58(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xc0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x6670
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
callq 0x7840
callq 0x5a40
movq -0x20(%rbp), %rdi
movq %rax, 0x18(%rdi)
movl $0x2, (%rdi)
callq 0x5f30
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rdi), %rsi
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rcx
leaq 0x13f44(%rip), %rdi     # 0x1a59b
movb $0x0, %al
callq 0x5b70
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_bitcast_from_i8p(Type*, llvalue_t)
llvalue_t llvm_bitcast_from_i8p(Type *type, llvalue_t ptr) {
    llvalue_t v;
    assert(ptr.kind == LLVALUE::REG);
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    // Assume that `ptr` has type i8*
    switch (type->kind) {
    case TY::BOOL:
    {
        emit("%%%ld = bitcast i8* %%%ld to i1*\n", v.reg, ptr.reg);
    } break;
    case TY::INT:
    {
        emit("%%%ld = bitcast i8* %%%ld to i32*\n", v.reg, ptr.reg);
    } break;
    case TY::ARR:
    {
        emit("%%%ld = bitcast i8* %%%ld to i32**\n", v.reg, ptr.reg);
    } break;
    case TY::ID:
    {
        emit("%%%ld = bitcast i8* %%%ld to i8**\n", v.reg, ptr.reg);
    } break;
    default: assert(0);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
callq 0x7840
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x669f
jmp 0x66be
leaq 0x13d43(%rip), %rdi     # 0x1a3e9
leaq 0x13b04(%rip), %rsi     # 0x1a1b1
movl $0xf8, %edx
leaq 0x13d49(%rip), %rcx     # 0x1a402
callq 0x20d0
callq 0x5a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x2, (%rax)
callq 0x5f30
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x6785
movq -0x28(%rbp), %rax
leaq 0x138a0(%rip), %rcx     # 0x19f9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13d19(%rip), %rdi     # 0x1a435
movb $0x0, %al
callq 0x5b70
jmp 0x67a4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13d1b(%rip), %rdi     # 0x1a457
movb $0x0, %al
callq 0x5b70
jmp 0x67a4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13d1e(%rip), %rdi     # 0x1a47a
movb $0x0, %al
callq 0x5b70
jmp 0x67a4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13d22(%rip), %rdi     # 0x1a49e
movb $0x0, %al
callq 0x5b70
jmp 0x67a4
leaq 0x151f6(%rip), %rdi     # 0x1b982
leaq 0x13a1e(%rip), %rsi     # 0x1a1b1
movl $0x10e, %edx            # imm = 0x10E
leaq 0x13c63(%rip), %rcx     # 0x1a402
callq 0x20d0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x5a40
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rdx
movl -0x8(%rbp), %ecx
callq 0x5ad0
callq 0x5f30
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rdi), %rsi
movq 0x18(%rax), %rdx
leaq 0x13cb6(%rip), %rdi     # 0x1a4c1
movb $0x0, %al
callq 0x5b70
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x5a40
movq %rax, %rsi
movq $0x0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %ecx
leaq -0x28(%rbp), %rdi
callq 0x5ad0
callq 0x5f30
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x13c6a(%rip), %rdi     # 0x1a4e5
movb $0x0, %al
callq 0x5b70
callq 0x5f30
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdx
leaq 0x13c76(%rip), %rdi     # 0x1a510
movb $0x0, %al
callq 0x5b70
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, (%rax)
jne 0x68d7
jmp 0x68f6
leaq 0x13b0b(%rip), %rdi     # 0x1a3e9
leaq 0x138cc(%rip), %rsi     # 0x1a1b1
movl $0x125, %edx            # imm = 0x125
leaq 0x13c3e(%rip), %rcx     # 0x1a52f
callq 0x20d0
movq -0x40(%rbp), %rdi
callq 0x7840
callq 0x5a40
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x2, (%rax)
callq 0x5f30
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13c35(%rip), %rdi     # 0x1a566
movb $0x0, %al
callq 0x5b70
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x13db5(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x5b70
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq