LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/olly-larkin[P]mips-parser/src/instructionList.cpp
// Function: giveStr(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string giveStr(std::vector<std::string> strVec) {
    std::string returnStr;
    for(int i = 0; i < strVec.size(); ++i) {
        returnStr += strVec[i] + ' ';
    }
    return returnStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x60d4
addq %r13, %rsi
movq %r15, %rdi
pushq $0x20
popq %rdx
callq 0x871e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2370
movq %r15, %rdi
callq 0x2120
incq %r12
addq $0x20, %r13
jmp 0x6097
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0x60f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/olly-larkin[P]mips-parser/src/instructionList.cpp
// Function: regCheck(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<int, std::allocator<int>> const&)
bool regCheck(std::vector<std::string>& argVec, const std::vector<int>& index) {
    for(int i = 0; i < index.size(); ++i) {
        if (argVec[index[i]].back() == ',')
            argVec[index[i]].pop_back();
        if (regMap.find(argVec[index[i]]) == regMap.end())
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
leaq 0x8134(%rip), %r12      # 0xe258
movq %rcx, %r13
movq (%rbx), %rax
movq 0x8(%rbx), %r15
subq %rax, %r15
sarq $0x2, %r15
cmpq %rcx, %r15
jbe 0x6186
movslq (%rax,%r13,4), %rsi
movq (%r14), %rdi
movq %rsi, %rax
shlq $0x5, %rax
movq (%rdi,%rax), %rcx
movq 0x8(%rdi,%rax), %rdx
cmpb $0x2c, -0x1(%rcx,%rdx)
jne 0x616a
addq %rax, %rdi
callq 0x2230
movq (%rbx), %rax
movslq (%rax,%r13,4), %rsi
movq (%r14), %rdi
shlq $0x5, %rsi
addq %rdi, %rsi
leaq 0x80d8(%rip), %rdi      # 0xe250
callq 0x5ff0
leaq 0x1(%r13), %rcx
cmpq %r12, %rax
jne 0x6124
cmpq %r13, %r15
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq -0x30(%rbp), %r13
xorl %r15d, %r15d
movq %r13, %rsi
xorl %edx, %edx
callq 0x4908
movl %eax, (%r12)
movq (%r13), %rax
testq %rax, %rax
je 0x6bca
movq (%r14), %rcx
cmpb $0x28, (%rcx,%rax)
jne 0x6b88
movq %r14, %rdi
callq 0x2230
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl -0x30(%rbp), %r12d
incl %r12d
leaq -0x50(%rbp), %r15
movslq %r12d, %r12
cmpq %r12, 0x8(%r14)
jbe 0x6b8d
movq (%r14), %rax
movsbl (%rax,%r12), %esi
incl %r12d
movq %r15, %rdi
callq 0x2180
jmp 0x6b6a
xorl %r15d, %r15d
jmp 0x6bca
leaq 0x76bc(%rip), %rdi      # 0xe250
leaq -0x50(%rbp), %rsi
callq 0x5ff0
leaq 0x76b4(%rip), %rcx      # 0xe258
cmpq %rcx, %rax
setne %r15b
je 0x6bc1
leaq 0x769c(%rip), %rdi      # 0xe250
leaq -0x50(%rbp), %rsi
callq 0x493a
movl (%rax), %eax
movl %eax, (%rbx)
leaq -0x50(%rbp), %rdi
callq 0x2120
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6be0
jmp 0x6be0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/olly-larkin[P]mips-parser/src/instructionList.cpp
// Function: j(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, int)
uint32_t j(std::vector<std::string>& argVec, int i) {
    uint32_t returnNum = ((2 << 26) & 0xFC000000);
    int32_t addr;
    if(!labelReturn(argVec[1], addr)) {
        if (!validIntStr(argVec[1], addr))
            exitError("Invalid address \"" + giveStr(argVec) + "\" on instruction number " + std::to_string(i+1), 5);
    }
    return returnNum | (((addr) >> 2) & 0x3FFFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
addq $0x20, %rsi
leaq -0x100(%rbp), %r15
movq %r15, %rdi
callq 0x2280
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x4753
movl %eax, %r15d
leaq -0x100(%rbp), %rdi
callq 0x2120
testb %r15b, %r15b
jne 0x839b
movq (%r14), %rsi
addq $0x20, %rsi
leaq -0xe0(%rbp), %r15
movq %r15, %rdi
callq 0x2280
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3f5c
movl %eax, %r15d
leaq -0xe0(%rbp), %rdi
callq 0x2120
testb %r15b, %r15b
je 0x83b9
movl -0x1c(%rbp), %eax
shrl $0x2, %eax
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
orl $0x8000000, %eax        # imm = 0x8000000
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x118(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d5c
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x6066
leaq 0x10e3(%rip), %rsi      # 0x94c1
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x8759
leaq 0xe15(%rip), %rdx       # 0x9207
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3e83
incl %ebx
leaq -0x40(%rbp), %rdi
movl %ebx, %esi
callq 0x8787
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a7a
leaq -0xc0(%rbp), %rdi
pushq $0x5
popq %rsi
callq 0x6038
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x2120
jmp 0x8449
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x8457
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2120
jmp 0x8468
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2120
jmp 0x8476
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x8484
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3ef4
jmp 0x84ad
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
jmp 0x84a8
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/olly-larkin[P]mips-parser/src/instructionList.cpp
// Function: jal(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, int)
uint32_t jal(std::vector<std::string>& argVec, int i) {
    uint32_t returnNum = ((3 << 26) & 0xFC000000);
    int32_t addr;
    if(!labelReturn(argVec[1], addr)) {
        if (!validIntStr(argVec[1], addr))
            exitError("Invalid address \"" + giveStr(argVec) + "\" on instruction number " + std::to_string(i+1), 5);
    }
    return returnNum | (((addr) >> 2) & 0x3FFFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
addq $0x20, %rsi
leaq -0x100(%rbp), %r15
movq %r15, %rdi
callq 0x2280
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x4753
movl %eax, %r15d
leaq -0x100(%rbp), %rdi
callq 0x2120
testb %r15b, %r15b
jne 0x8536
movq (%r14), %rsi
addq $0x20, %rsi
leaq -0xe0(%rbp), %r15
movq %r15, %rdi
callq 0x2280
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3f5c
movl %eax, %r15d
leaq -0xe0(%rbp), %rdi
callq 0x2120
testb %r15b, %r15b
je 0x8554
movl -0x1c(%rbp), %eax
shrl $0x2, %eax
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
orl $0xc000000, %eax        # imm = 0xC000000
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x118(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d5c
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x6066
leaq 0xf48(%rip), %rsi       # 0x94c1
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x8759
leaq 0xc7a(%rip), %rdx       # 0x9207
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3e83
incl %ebx
leaq -0x40(%rbp), %rdi
movl %ebx, %esi
callq 0x8787
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a7a
leaq -0xc0(%rbp), %rdi
pushq $0x5
popq %rsi
callq 0x6038
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x2120
jmp 0x85e4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x85f2
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2120
jmp 0x8603
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2120
jmp 0x8611
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x861f
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3ef4
jmp 0x8648
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
jmp 0x8643
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15e11(%rip), %r13     # 0x18100
movq (%r13,%r12,8), %r15
testq %r15, %r15
je 0x238f
movq %rdi, %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
cmpq %rcx, %rbx
jbe 0x2379
movq 0x162d9(%rip), %rax     # 0x185f8
movq %rax, (%r15)
testq %rax, %rax
je 0x2343
movq (%rax), %rax
movq %rax, 0x162c7(%rip)     # 0x185f8
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 0x23c5
addq %rax, %r14
movq %r14, 0x10(%rax)
movq %rax, %r15
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
andq $0x0, (%r15)
movq %r15, (%r13,%r12,8)
movq 0x8(%r15), %rax
addq %rax, %rbx
movq %rbx, 0x8(%r15)
testq %rax, %rax
je 0x23a8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xf658(%rip), %rdi      # 0x119ee
leaq 0xbc67(%rip), %rsi      # 0xe004
leaq 0xbc6a(%rip), %rcx      # 0xe00e
pushq $0x41
jmp 0x23bf
leaq 0xbc97(%rip), %rdi      # 0xe046
leaq 0xbc4e(%rip), %rsi      # 0xe004
leaq 0xbc51(%rip), %rcx      # 0xe00e
pushq $0x5a
popq %rdx
callq 0x20b0
leaq 0xbc5e(%rip), %rdi      # 0xe02a
leaq 0xbc31(%rip), %rsi      # 0xe004
leaq 0xbc34(%rip), %rcx      # 0xe00e
pushq $0x51
jmp 0x23bf
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15d01(%rip), %rcx     # 0x18100
movq (%rcx,%rax,8), %rdx
cmpq $0x0, (%rdx)
je 0x2436
movq 0x161e8(%rip), %rsi     # 0x185f8
movq %rsi, (%rdx)
imulq $0x18, %rax, %rdx
leaq 0x16132(%rip), %rsi     # 0x18550
leaq (%rsi,%rdx), %rdi
movq (%rdx,%rsi), %r8
movq %r8, 0x161cb(%rip)      # 0x185f8
andq $0x0, (%rdx,%rsi)
movq %rdi, (%rcx,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbcf9(%rip), %rax      # 0xe138
movq %rax, 0x161c2(%rip)     # 0x18608
leaq 0x161b3(%rip), %rax     # 0x18600
leaq 0xbcf2(%rip), %rcx      # 0xe146
movq %rcx, 0x161b5(%rip)     # 0x18610
leaq 0xbcf2(%rip), %rcx      # 0xe154
movq %rcx, 0x161af(%rip)     # 0x18618
leaq 0xbcf5(%rip), %rcx      # 0xe165
movq %rcx, 0x161a9(%rip)     # 0x18620
leaq 0xbcf9(%rip), %rcx      # 0xe177
movq %rcx, 0x161a3(%rip)     # 0x18628
leaq 0xbcfd(%rip), %rcx      # 0xe189
movq %rcx, 0x1619d(%rip)     # 0x18630
leaq 0xbcfb(%rip), %rcx      # 0xe195
movq %rcx, 0x16197(%rip)     # 0x18638
leaq 0xbcf9(%rip), %rcx      # 0xe1a1
movq %rcx, 0x16191(%rip)     # 0x18640
leaq 0xbcf7(%rip), %rcx      # 0xe1ad
movq %rcx, 0x1618b(%rip)     # 0x18648
leaq 0xbcf7(%rip), %rcx      # 0xe1bb
movq %rcx, 0x16185(%rip)     # 0x18650
leaq 0xbcf4(%rip), %rcx      # 0xe1c6
movq %rcx, 0x1617f(%rip)     # 0x18658
leaq 0xbcf5(%rip), %rcx      # 0xe1d5
movq %rcx, 0x16179(%rip)     # 0x18660
leaq 0xbcf3(%rip), %rcx      # 0xe1e1
movq %rcx, 0x16173(%rip)     # 0x18668
leaq 0xbcf4(%rip), %rcx      # 0xe1f0
movq %rcx, 0x1616d(%rip)     # 0x18670
leaq 0xbceb(%rip), %rcx      # 0xe1f5
movq %rcx, 0x16167(%rip)     # 0x18678
leaq 0xbcf2(%rip), %rcx      # 0xe20a
movq %rcx, 0x160e1(%rip)     # 0x18600
movslq %edi, %rcx
movq (%rax,%rcx,8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xbb0f(%rip), %rdi      # 0xe2d8
xorl %eax, %eax
callq 0x3228
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x27f4
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x27df
leaq 0xe020(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2818
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xbaa1(%rip), %rdi      # 0xe2e8
xorl %eax, %eax
callq 0x3228
movq 0x10(%rbx), %rsi
leaq 0xbaa4(%rip), %rdi      # 0xe2fd
xorl %eax, %eax
callq 0x317b
movq 0x18(%rbx), %rdi
callq 0x2527
leaq 0xdfab(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xba5a(%rip), %rdi      # 0xe30f
xorl %eax, %eax
callq 0x3228
movq 0x10(%rbx), %rsi
leaq 0xba36(%rip), %rdi      # 0xe2fd
xorl %eax, %eax
callq 0x317b
movq 0x18(%rbx), %rdi
callq 0x2527
movq 0x20(%rbx), %rdi
callq 0x2527
leaq 0xdf34(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xb9fc(%rip), %rdi      # 0xe329
xorl %eax, %eax
callq 0x3228
leaq 0xb9fb(%rip), %rdi      # 0xe336
xorl %eax, %eax
callq 0x317b
leaq 0xe(%rsp), %rdi
callq 0x3108
movq 0x10(%rbx), %rdi
callq 0x2527
leaq 0xe(%rsp), %rdi
callq 0x311c
leaq 0xb9da(%rip), %rdi      # 0xe340
xorl %eax, %eax
callq 0x317b
leaq 0xd(%rsp), %rdi
callq 0x3108
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x311c
leaq 0xb9b8(%rip), %rdi      # 0xe34a
xorl %eax, %eax
callq 0x317b
leaq 0xc(%rsp), %rdi
callq 0x3108
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xc(%rsp), %rdi
callq 0x311c
leaq 0xde5d(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x29f5
jmp 0x29fe
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x29f5
jmp 0x29fe
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x311c
jmp 0x2a01
jmp 0x29fe
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xb927(%rip), %rdi      # 0xe354
xorl %eax, %eax
callq 0x3228
leaq 0xb8fb(%rip), %rdi      # 0xe336
xorl %eax, %eax
callq 0x317b
leaq 0xe(%rsp), %rdi
callq 0x3108
movq 0x10(%rbx), %rdi
callq 0x2527
leaq 0xe(%rsp), %rdi
callq 0x311c
leaq 0xb8fe(%rip), %rdi      # 0xe364
xorl %eax, %eax
callq 0x317b
leaq 0xd(%rsp), %rdi
callq 0x3108
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x311c
leaq 0xdd89(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x2abd
jmp 0x2ac6
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x311c
jmp 0x2ac9
jmp 0x2ac6
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0xb879(%rip), %rdi      # 0xe36e
xorl %eax, %eax
callq 0x3228
movq 0x10(%rbx), %rdi
callq 0x2527
leaq 0xdd0f(%rip), %rdi      # 0x1081b
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b86
movl %edi, %eax
leaq 0xb542(%rip), %rcx      # 0xe088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb828(%rip), %rdi      # 0xe37e
jmp 0x2b7f
leaq 0xb84c(%rip), %rdi      # 0xe3ab
xorl %eax, %eax
jmp 0x2030
leaq 0xb832(%rip), %rdi      # 0xe39f
jmp 0x2b7f
leaq 0xb82d(%rip), %rdi      # 0xe3a3
jmp 0x2b7f
leaq 0xb81a(%rip), %rdi      # 0xe399
xorl %eax, %eax
jmp 0x2030
pushq %rax
leaq 0xda84(%rip), %rdi      # 0x10612
leaq 0xb700(%rip), %rsi      # 0xe295
leaq 0xb81b(%rip), %rcx      # 0xe3b7
movl $0xcd, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
orq %rsi, %rax
jne 0x2c11
leaq 0xb7fc(%rip), %rdi      # 0xe401
xorl %eax, %eax
callq 0x3228
jmp 0x2cd8
leaq 0xb80b(%rip), %rdi      # 0xe423
xorl %eax, %eax
callq 0x317b
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2c38
leaq 0xb808(%rip), %rdi      # 0xe437
xorl %eax, %eax
callq 0x2030
jmp 0x2c40
pushq $0xa
popq %rdi
callq 0x2160
leaq 0x6(%rsp), %rdi
callq 0x3108
leaq 0xb7f5(%rip), %rdi      # 0xe446
xorl %eax, %eax
callq 0x317b
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2c7b
movq (%r15,%r12), %rdi
callq 0x2d24
addq $0x8, %r12
jmp 0x2c67
leaq 0x6(%rsp), %rdi
callq 0x311c
leaq 0x5(%rsp), %rdi
callq 0x3108
leaq 0xb7be(%rip), %rdi      # 0xe454
xorl %eax, %eax
callq 0x317b
movq 0x38(%rbx), %r14
movq 0x40(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x2cc0
movq (%rbx,%r15), %rdi
callq 0x2d66
addq $0x8, %r15
jmp 0x2cac
leaq 0x5(%rsp), %rdi
callq 0x311c
leaq 0xe3e3(%rip), %rdi      # 0x110b4
xorl %eax, %eax
callq 0x317b
leaq 0x7(%rsp), %rdi
callq 0x311c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2cfb
jmp 0x2cf6
jmp 0x2d05
jmp 0x2cf6
movq %rax, %rbx
jmp 0x2d12
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x2d0d
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x311c
leaq 0x7(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2e71
leaq 0xb6f5(%rip), %rdi      # 0xe489
xorl %eax, %eax
callq 0x317b
leaq 0xe(%rsp), %rdi
callq 0x3108
leaq 0xb6f4(%rip), %rdi      # 0xe4a0
xorl %eax, %eax
callq 0x317b
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2dd6
movq (%r15,%r12), %rdi
callq 0x2d24
addq $0x8, %r12
jmp 0x2dc2
leaq 0xe(%rsp), %rdi
callq 0x311c
leaq 0xd(%rsp), %rdi
callq 0x3108
leaq 0xb6bc(%rip), %rdi      # 0xe4ad
xorl %eax, %eax
callq 0x317b
movq 0x58(%rbx), %r15
movq 0x60(%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2e2c
movq (%r12,%r13), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x2e26
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x8, %r13
jmp 0x2e07
leaq 0xd(%rsp), %rdi
callq 0x311c
leaq 0xc(%rsp), %rdi
callq 0x3108
leaq 0xb66d(%rip), %rdi      # 0xe4b4
xorl %eax, %eax
callq 0x317b
movq 0x68(%rbx), %rdi
callq 0x2527
leaq 0xc(%rsp), %rdi
callq 0x311c
leaq 0xe24c(%rip), %rdi      # 0x110b4
xorl %eax, %eax
callq 0x317b
jmp 0x2e7f
leaq 0xb5ed(%rip), %rdi      # 0xe465
xorl %eax, %eax
callq 0x3228
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2eab
jmp 0x2eba
jmp 0x2eab
jmp 0x2eb0
jmp 0x2eab
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x2ec2
movq %rax, %rbx
jmp 0x2ec7
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
jmp 0x2ec2
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
callq 0x311c
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
movq 0x8(%rbx), %rsi
leaq 0xb5c3(%rip), %rdi      # 0xe4bd
xorl %eax, %eax
callq 0x317b
leaq 0x6(%rsp), %rdi
callq 0x3108
leaq 0xb5ba(%rip), %rdi      # 0xe4cc
xorl %eax, %eax
callq 0x317b
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2f3c
movq (%r15,%r12), %rdi
callq 0x2d24
addq $0x8, %r12
jmp 0x2f28
leaq 0x6(%rsp), %rdi
callq 0x311c
leaq 0x5(%rsp), %rdi
callq 0x3108
leaq 0xb591(%rip), %rdi      # 0xe4e8
xorl %eax, %eax
callq 0x317b
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x2f82
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x2f6d
leaq 0x5(%rsp), %rdi
callq 0x311c
leaq 0xe121(%rip), %rdi      # 0x110b4
xorl %eax, %eax
callq 0x317b
leaq 0x7(%rsp), %rdi
callq 0x311c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2fbd
jmp 0x2fb8
jmp 0x2fc7
jmp 0x2fb8
movq %rax, %rbx
jmp 0x2fd4
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x2fcf
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x311c
leaq 0x7(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3108
leaq 0x8(%rbx), %rdi
callq 0x2eda
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x3028
movq (%rbx,%r15), %rdi
callq 0x2bdc
addq $0x8, %r15
jmp 0x3014
leaq 0xf(%rsp), %rdi
callq 0x311c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x303e
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x311c
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x158ff(%rip), %rcx     # 0x18a38
movl 0x15541(%rip), %eax     # 0x18680
testl %eax, %eax
setg %dl
andb (%rcx), %dl
cmpb $0x1, %dl
jne 0x3174
leaq 0xb43b(%rip), %rbx      # 0xe58d
xorl %ebp, %ebp
decl %eax
cmpl %eax, %ebp
je 0x3174
movl 0x15524(%rip), %esi     # 0x18684
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
incl %ebp
movl 0x1550e(%rip), %eax     # 0x18680
jmp 0x3154
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31c0
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 0x15858(%rip), %rax     # 0x18a38
cmpb $0x1, (%rax)
jne 0x321d
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 0x312f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x326a
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 0x157ae(%rip), %rax     # 0x18a38
cmpb $0x1, (%rax)
jne 0x32c3
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 0x317b
pushq $0xa
popq %rdi
callq 0x2160
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x151a8(%rip), %edi     # 0x18690
callq 0x41c3
callq 0x41f9
leaq 0xb75b(%rip), %rdi      # 0xec54
xorl %eax, %eax
callq 0x2030
callq 0x4226
movq %rbx, %rdi
callq 0x4215
pushq $0xa
popq %rdi
popq %rbx
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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 0x148b0(%rip), %xmm0    # 0x18698
movaps %xmm0, (%rsp)
movl 0x1489e(%rip), %ebx     # 0x18690
movq 0x148af(%rip), %r14     # 0x186a8
callq 0x351d
movl 0x14894(%rip), %eax     # 0x18698
movq 0x14895(%rip), %rdx     # 0x186a0
movq %r14, 0x14896(%rip)     # 0x186a8
movl %ebx, 0x14878(%rip)     # 0x18690
movaps (%rsp), %xmm0
movups %xmm0, 0x14875(%rip)    # 0x18698
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1479b(%rip), %rcx     # 0x186b0
leaq 0xa844(%rip), %rdx      # 0xe760
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
cmpq $0x100, %rax            # imm = 0x100
je 0x3f9a
movl %eax, %r8d
andl $0xf8, %r8d
cmpl $0x30, %r8d
jne 0x3f42
orb $0x10, (%rax,%rcx)
movzbl %al, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x3f86
movb $0x8, %r8b
btq %r9, %rsi
jae 0x3f86
orb %r8b, (%rax,%rcx)
movzbl %al, %r8d
addl $-0x9, %r8d
cmpl $0x75, %r8d
ja 0x3f81
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
movb $0x2, %r8b
jmp 0x3f7d
movb $0x20, %r8b
orb %r8b, (%rax,%rcx)
incq %rax
jmp 0x3f26
leal -0x30(%rax), %r9d
movb $0xc, %r8b
cmpl $0x9, %r9d
jbe 0x3f59
jmp 0x3f5d
movb $0x1, %r8b
jmp 0x3f7d
xorl %ecx, %ecx
leaq 0x1480d(%rip), %rax     # 0x187b0
cmpq $0xa, %rcx
je 0x3fb3
movw %cx, 0x60(%rax,%rcx,2)
incq %rcx
jmp 0x3fa3
xorl %ecx, %ecx
cmpq $0x6, %rcx
je 0x3fcb
leal 0xa(%rcx), %edx
movw %dx, 0xc2(%rax,%rcx,2)
incq %rcx
jmp 0x3fb5
movl $0x1, 0x146bb(%rip)     # 0x18690
jmp 0x3ef6
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4340
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 0x146d8(%rip), %rax     # 0x18a38
cmpb $0x1, 0x4(%rax)
jne 0x4390
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_O2/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 0x43dd
leaq 0xa8ad(%rip), %rsi      # 0xec70
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 0x43fa
cmpl $0x3c, %esi
jne 0x4410
xorl %eax, %eax
cmpl %ecx, %edx
setl %al
movl %eax, %ecx
jmp 0x43fa
subl %ecx, %edx
movl %edx, %ecx
jmp 0x43fa
addl %edx, %ecx
jmp 0x43fa
imull %edx, %ecx
movl $0x1, (%rdi)
movl %ecx, 0x18(%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xc1fa(%rip), %rdi      # 0x10612
leaq 0xaab6(%rip), %rsi      # 0xeed5
leaq 0xaab8(%rip), %rcx      # 0xeede
pushq $0x67
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4453
movl 0x18(%rax), %esi
testb %dil, %dil
je 0x4466
cmpl $0x1, %esi
je 0x4475
testl %esi, %esi
jne 0x4484
leaq 0xb225(%rip), %rdi      # 0xf676
jmp 0x447c
movq 0x18(%rax), %rsi
leaq 0xb1b8(%rip), %rdi      # 0xf616
xorl %eax, %eax
popq %rcx
jmp 0x42fe
leaq 0xb55f(%rip), %rdi      # 0xf9cc
xorl %eax, %eax
popq %rcx
jmp 0x42fe
leaq 0xb200(%rip), %rdi      # 0xf67c
xorl %eax, %eax
popq %rcx
jmp 0x42fe
leaq 0xb1f6(%rip), %rdi      # 0xf681
leaq 0xaa43(%rip), %rsi      # 0xeed5
leaq 0xb1b3(%rip), %rcx      # 0xf64c
pushq $0x74
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x28, %rsp
callq 0x44e4
leaq 0xaa54(%rip), %rdi      # 0xef05
xorl %eax, %eax
callq 0x42fe
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %edi, %edi
callq 0x442e
leaq 0xcbdb(%rip), %rdi      # 0x110b4
xorl %eax, %eax
addq $0x28, %rsp
jmp 0x42fe
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x70(%rsp), %r12
leaq 0x50(%rsp), %r13
cmpl $0x1, (%r13)
jne 0x454d
cmpl $0x1, 0x70(%rsp)
jne 0x454d
movl 0x18(%r13), %edx
movl 0x18(%r12), %ecx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x43b4
jmp 0x462e
movq 0x144d4(%rip), %r14     # 0x18a28
leaq 0x1(%r14), %rax
movq %rax, 0x144c9(%rip)     # 0x18a28
callq 0x44e4
leaq 0xa9b4(%rip), %rdi      # 0xef1f
movq %r14, %rsi
xorl %eax, %eax
callq 0x42fe
leal -0x26(%r15), %eax
cmpl $0x7, %eax
ja 0x4597
leaq 0xa70b(%rip), %rcx      # 0xec90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa9bc(%rip), %rdi      # 0xef51
jmp 0x45c3
cmpl $0x3c, %r15d
jne 0x463f
leaq 0xa99b(%rip), %rdi      # 0xef43
jmp 0x45c3
leaq 0xa980(%rip), %rdi      # 0xef31
jmp 0x45c3
leaq 0xa96e(%rip), %rdi      # 0xef28
jmp 0x45c3
leaq 0xa977(%rip), %rdi      # 0xef3a
xorl %eax, %eax
callq 0x42fe
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %edi, %edi
callq 0x442e
leaq 0xc735(%rip), %rdi      # 0x10d20
xorl %eax, %eax
callq 0x42fe
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %edi, %edi
callq 0x442e
leaq 0xae54(%rip), %rdi      # 0xf468
xorl %eax, %eax
callq 0x42fe
movl $0x2, (%rbx)
movq %r14, 0x18(%rbx)
andq $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xbfcc(%rip), %rdi      # 0x10612
leaq 0xa888(%rip), %rsi      # 0xeed5
leaq 0xa905(%rip), %rcx      # 0xef59
movl $0x9f, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x465e
leaq 0xa8fa(%rip), %rdi      # 0xefb1
xorl %eax, %eax
callq 0x42fe
cmpq $0x0, 0x10(%rbx)
je 0x46d3
leaq 0xc654(%rip), %rdi      # 0x10d20
xorl %eax, %eax
callq 0x42fe
leaq 0xc646(%rip), %r14      # 0x10d20
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r15
je 0x470f
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
callq 0x465e
movq 0x10(%rbx), %rax
decq %rax
cmpq %rax, %r15
je 0x470a
movq %r14, %rdi
xorl %eax, %eax
callq 0x42fe
incq %r15
jmp 0x46dd
leaq 0xa8a1(%rip), %rdi      # 0xefb7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x42fe
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
cmpb $0x2, 0x38(%rsi)
jne 0x4939
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %eax
movl $0x2, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
andl $0x0, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
addl $0x8, %eax
movslq %eax, %rsi
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x4958
movups 0x8(%r15), %xmm0
movq 0x18(%r15), %rax
movq (%r15), %rcx
movq 0x8(%r14), %rsi
movq %rcx, 0x40(%rsp)
movups %xmm0, 0x48(%rsp)
movq %rax, 0x58(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x49aa
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa781(%rip), %rdi      # 0xf0c1
leaq 0xa58e(%rip), %rsi      # 0xeed5
leaq 0xa799(%rip), %rcx      # 0xf0e7
movl $0xee, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x10(%rdi)
movq 0x140ba(%rip), %r15     # 0x18a28
leaq 0x1(%r15), %rax
movq %rax, 0x140af(%rip)     # 0x18a28
movq %r15, 0x18(%rdi)
movl $0x2, (%rdi)
callq 0x44e4
movq 0x38(%rsp), %rdx
leaq 0xa92b(%rip), %rdi      # 0xf2bf
movq %r15, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x42fe
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x13fc4(%rip), %r14     # 0x18a28
leaq 0x1(%r14), %rax
movl $0x2, (%rdi)
movq %r14, 0x18(%rdi)
andq $0x0, 0x8(%rdi)
movq %rax, 0x13faa(%rip)     # 0x18a28
andl $0x0, 0x10(%rdi)
callq 0x44e4
movq 0x38(%rsp), %rdx
leaq 0xa752(%rip), %rdi      # 0xf1e5
movq %r14, %rsi
xorl %eax, %eax
callq 0x42fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x13f72(%rip), %r14     # 0x18a28
leaq 0x1(%r14), %rax
movq %rax, 0x13f67(%rip)     # 0x18a28
callq 0x44e4
movq 0x8(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0xa734(%rip), %rdi      # 0xf209
movq %r14, %rsi
xorl %eax, %eax
callq 0x42fe
callq 0x44e4
movq 0x38(%rsp), %rdx
leaq 0xa744(%rip), %rdi      # 0xf234
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42fe