LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/olly-larkin[P]mips-parser/src/parser.cpp
// Function: validIntStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&)
bool validIntStr(std::string arg, int32_t& returnVal){
    std::size_t pos;
    returnVal = std::stoi(arg, &pos,0);
    if(pos != arg.length()){
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
callq 0x2050
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x22c0
movq (%r13), %rcx
subq %r12, %rcx
je 0x41d0
movslq %eax, %rdx
cmpq %rax, %rdx
jne 0x41dc
movl (%rbx), %edx
cmpl $0x22, %edx
je 0x41dc
testl %edx, %edx
jne 0x41b7
movl -0x2c(%rbp), %edx
movl %edx, (%rbx)
movl %eax, (%r15)
cmpq 0x8(%r14), %rcx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x703d(%rip), %rdi      # 0xb214
callq 0x2150
leaq 0x7031(%rip), %rdi      # 0xb214
callq 0x22e0
cmpl $0x0, (%rbx)
jne 0x41f2
movl -0x2c(%rbp), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/olly-larkin[P]mips-parser/src/parser.cpp
// Function: vecParser(std::istream&, std::vector<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::allocator<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>>>>>>&)
void vecParser(std::istream& inStream, std::vector< std::vector<std::string> >& commVector) {
    std::string inComm;
    unsigned int count = 0x10000000;

    while(1) {
        if (!(inStream >> inComm) || !(addVec(inStream, commVector, count, inComm)))
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x2c(%rbp), %rax
movl $0x10000000, (%rax)     # imm = 0x10000000
leaq -0x58(%rbp), %r12
leaq -0x78(%rbp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x22a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebx
movb $0x1, %r15b
testb $0x5, %bl
jne 0x428a
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x40bc
movq %r14, %rdi
movq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %r13, %rcx
callq 0x42fb
movl %eax, %r15d
xorb $0x1, %r15b
testb $0x5, %bl
jne 0x42a1
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x42a1
callq 0x21f0
testb %r15b, %r15b
je 0x4237
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x42b8
callq 0x21f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x42e1
callq 0x21f0
jmp 0x42e1
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x42f3
callq 0x21f0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/olly-larkin[P]mips-parser/src/parser.cpp
// Function: labelReturn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&)
bool labelReturn(std::string str, int32_t& addr) {
    if (labelMap.find(str) == labelMap.end())
        return false;
    addr = labelMap[str];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa499(%rip), %rdi      # 0xf240
movq %r14, %rsi
callq 0x65d4
movq %rax, %r15
leaq 0xa48f(%rip), %r12      # 0xf248
cmpq %r12, %rax
je 0x4dd1
leaq 0xa47b(%rip), %rdi      # 0xf240
movq %r14, %rsi
callq 0x4e78
movl (%rax), %eax
movl %eax, (%rbx)
cmpq %r12, %r15
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0x10(%rdi), %rax
movq %rax, -0x58(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x6704
movq %rsi, %r14
movl $0x8, %r12d
leaq -0x40(%rbp), %r13
xorl %ebx, %ebx
leaq -0x50(%rbp), %r15
movq %r13, -0x50(%rbp)
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x40bc
movq -0x48(%rbp), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x66ea
callq 0x21f0
incq %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %rbx, %rcx
ja 0x669a
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x672f
jmp 0x671e
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x672f
callq 0x21f0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x58(%rbp), %rdi
je 0x6741
callq 0x21f0
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpq %rax, 0x8(%rsi)
sete %r15b
je 0x67d0
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x8b0c(%rip), %r12      # 0xf280
movslq (%rax,%r13,4), %rax
movq (%r14), %rdi
shlq $0x5, %rax
movq (%rdi,%rax), %rcx
movq 0x8(%rdi,%rax), %rdx
cmpb $0x2c, -0x1(%rcx,%rdx)
jne 0x6797
addq %rax, %rdi
callq 0x2280
movq (%rbx), %rax
movslq (%rax,%r13,4), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
leaq 0x8acc(%rip), %rdi      # 0xf278
callq 0x65d4
cmpq %r12, %rax
je 0x67d0
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
setbe %r15b
ja 0x6774
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %r15
callq 0x2050
movq %rax, %r12
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r12)
leaq -0x58(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22c0
movq (%rbx), %rbx
movq %rbx, %rcx
subq %r15, %rcx
je 0x7d01
movslq %eax, %rdx
cmpq %rax, %rdx
jne 0x7d0d
movl (%r12), %edx
cmpl $0x22, %edx
je 0x7d0d
testl %edx, %edx
jne 0x7c4e
movl -0x2c(%rbp), %edx
movl %edx, (%r12)
movl %eax, (%r13)
cmpq %r15, %rbx
je 0x7ca4
movq (%r14), %rax
cmpb $0x28, (%rax,%rcx)
jne 0x7ca4
movq %r14, %rdi
callq 0x2280
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
subl %r15d, %ebx
incl %ebx
leaq -0x58(%rbp), %r15
movslq %ebx, %rbx
cmpq %rbx, 0x8(%r14)
jbe 0x7ca9
movq (%r14), %rax
movsbl (%rax,%rbx), %esi
incl %ebx
movq %r15, %rdi
callq 0x21c0
jmp 0x7c88
xorl %r14d, %r14d
jmp 0x7cef
leaq 0x75c8(%rip), %rdi      # 0xf278
leaq -0x58(%rbp), %rsi
callq 0x65d4
leaq 0x75c0(%rip), %rcx      # 0xf280
cmpq %rcx, %rax
setne %r14b
je 0x7ce1
leaq 0x75a8(%rip), %rdi      # 0xf278
leaq -0x58(%rbp), %rsi
callq 0x4e78
movl (%rax), %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x7cef
callq 0x21f0
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x350c(%rip), %rdi      # 0xb214
callq 0x2150
leaq 0x3500(%rip), %rdi      # 0xb214
callq 0x22e0
jmp 0x7d30
jmp 0x7d30
movq %rax, %rbx
cmpl $0x0, (%r12)
jne 0x7d41
movl -0x2c(%rbp), %eax
movl %eax, (%r12)
jmp 0x7d41
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x7d41
callq 0x21f0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
leaq 0x16e11(%rip), %r12     # 0x19100
movq (%r12,%r15,8), %r13
testq %r13, %r13
je 0x2398
movq %rdi, %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0x10(%r13), %rax
subq 0x8(%r13), %rax
cmpq %rax, %rbx
jbe 0x237e
movq 0x172dd(%rip), %rax     # 0x195f8
movq %rax, (%r13)
testq %rax, %rax
je 0x2348
movq 0x172cd(%rip), %rax     # 0x195f8
movq (%rax), %rax
movq %rax, 0x172c3(%rip)     # 0x195f8
movq (%r13), %r13
movq 0x10(%r13), %rcx
subq 0x8(%r13), %rcx
cmpq %rcx, %rbx
ja 0x232b
jmp 0x236a
leaq 0x2818(%rbx), %r14
movq %r14, %rdi
callq 0x2150
movq %rax, (%r13)
testq %rax, %rax
je 0x23d6
addq %rax, %r14
movq %r14, 0x10(%rax)
movq %rax, %r13
leaq 0x18(%r13), %rax
movq %rax, 0x8(%r13)
movq $0x0, (%r13)
movq %r13, (%r12,%r15,8)
movq 0x8(%r13), %rax
addq %rax, %rbx
movq %rbx, 0x8(%r13)
testq %rax, %rax
je 0x23b7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x116ee(%rip), %rdi     # 0x13a8d
leaq 0xdc5e(%rip), %rsi      # 0x10004
leaq 0xdc61(%rip), %rcx      # 0x1000e
movl $0x41, %edx
callq 0x20b0
leaq 0xdc88(%rip), %rdi      # 0x10046
leaq 0xdc3f(%rip), %rsi      # 0x10004
leaq 0xdc42(%rip), %rcx      # 0x1000e
movl $0x5a, %edx
callq 0x20b0
leaq 0xdc4d(%rip), %rdi      # 0x1002a
leaq 0xdc20(%rip), %rsi      # 0x10004
leaq 0xdc23(%rip), %rcx      # 0x1000e
movl $0x51, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16cea(%rip), %rcx     # 0x19100
movq (%rcx,%rax,8), %rdx
cmpq $0x0, (%rdx)
je 0x244e
movq 0x171d1(%rip), %rsi     # 0x195f8
movq %rsi, (%rdx)
leaq (%rax,%rax,2), %rdx
leaq 0x1711b(%rip), %rsi     # 0x19550
leaq (%rsi,%rdx,8), %rdx
movq (%rdx), %rsi
movq %rsi, 0x171b5(%rip)     # 0x195f8
movq $0x0, (%rdx)
movq %rdx, (%rcx,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdce1(%rip), %rax      # 0x10138
movq %rax, 0x171aa(%rip)     # 0x19608
leaq 0x1719b(%rip), %rax     # 0x19600
leaq 0xdcda(%rip), %rcx      # 0x10146
movq %rcx, 0x1719d(%rip)     # 0x19610
leaq 0xdcda(%rip), %rcx      # 0x10154
movq %rcx, 0x17197(%rip)     # 0x19618
leaq 0xdcdd(%rip), %rcx      # 0x10165
movq %rcx, 0x17191(%rip)     # 0x19620
leaq 0xdce1(%rip), %rcx      # 0x10177
movq %rcx, 0x1718b(%rip)     # 0x19628
leaq 0xdce5(%rip), %rcx      # 0x10189
movq %rcx, 0x17185(%rip)     # 0x19630
leaq 0xdce3(%rip), %rcx      # 0x10195
movq %rcx, 0x1717f(%rip)     # 0x19638
leaq 0xdce1(%rip), %rcx      # 0x101a1
movq %rcx, 0x17179(%rip)     # 0x19640
leaq 0xdcdf(%rip), %rcx      # 0x101ad
movq %rcx, 0x17173(%rip)     # 0x19648
leaq 0xdcdf(%rip), %rcx      # 0x101bb
movq %rcx, 0x1716d(%rip)     # 0x19650
leaq 0xdcdc(%rip), %rcx      # 0x101c6
movq %rcx, 0x17167(%rip)     # 0x19658
leaq 0xdcdd(%rip), %rcx      # 0x101d5
movq %rcx, 0x17161(%rip)     # 0x19660
leaq 0xdcdb(%rip), %rcx      # 0x101e1
movq %rcx, 0x1715b(%rip)     # 0x19668
leaq 0xdcdc(%rip), %rcx      # 0x101f0
movq %rcx, 0x17155(%rip)     # 0x19670
leaq 0xdcd3(%rip), %rcx      # 0x101f5
movq %rcx, 0x1714f(%rip)     # 0x19678
leaq 0xdcda(%rip), %rcx      # 0x1020a
movq %rcx, 0x170c9(%rip)     # 0x19600
movslq %edi, %rcx
movq (%rax,%rcx,8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd761(%rip), %rdi      # 0x102d8
xorl %eax, %eax
callq 0x35ee
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2ba5
movq 0x20(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r15, %r14
jne 0x2b92
leaq 0xfd0f(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2bc9
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd6f1(%rip), %rdi      # 0x102e8
xorl %eax, %eax
callq 0x35ee
movq 0x10(%rbx), %rsi
leaq 0xd6f4(%rip), %rdi      # 0x102fd
xorl %eax, %eax
callq 0x3541
movq 0x18(%rbx), %rdi
callq 0x253f
leaq 0xfc9b(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd6aa(%rip), %rdi      # 0x1030f
xorl %eax, %eax
callq 0x35ee
movq 0x10(%rbx), %rsi
leaq 0xd686(%rip), %rdi      # 0x102fd
xorl %eax, %eax
callq 0x3541
movq 0x18(%rbx), %rdi
callq 0x253f
movq 0x20(%rbx), %rdi
callq 0x253f
leaq 0xfc24(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd64c(%rip), %rdi      # 0x10329
xorl %eax, %eax
callq 0x35ee
leaq 0xd64b(%rip), %rdi      # 0x10336
xorl %eax, %eax
callq 0x3541
leaq 0xe(%rsp), %rdi
callq 0x34d0
movq 0x10(%rbx), %rdi
callq 0x253f
leaq 0xe(%rsp), %rdi
callq 0x34e4
leaq 0xd62a(%rip), %rdi      # 0x10340
xorl %eax, %eax
callq 0x3541
leaq 0xd(%rsp), %rdi
callq 0x34d0
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x34e4
leaq 0xd608(%rip), %rdi      # 0x1034a
xorl %eax, %eax
callq 0x3541
leaq 0xc(%rsp), %rdi
callq 0x34d0
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xc(%rsp), %rdi
callq 0x34e4
leaq 0xfb4d(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x2da5
jmp 0x2dae
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x2da5
jmp 0x2dae
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x34e4
jmp 0x2db1
jmp 0x2dae
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd577(%rip), %rdi      # 0x10354
xorl %eax, %eax
callq 0x35ee
leaq 0xd54b(%rip), %rdi      # 0x10336
xorl %eax, %eax
callq 0x3541
leaq 0xe(%rsp), %rdi
callq 0x34d0
movq 0x10(%rbx), %rdi
callq 0x253f
leaq 0xe(%rsp), %rdi
callq 0x34e4
leaq 0xd54e(%rip), %rdi      # 0x10364
xorl %eax, %eax
callq 0x3541
leaq 0xd(%rsp), %rdi
callq 0x34d0
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd(%rsp), %rdi
callq 0x34e4
leaq 0xfa79(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
jmp 0x2e6d
jmp 0x2e76
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0x34e4
jmp 0x2e79
jmp 0x2e76
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0xd4c9(%rip), %rdi      # 0x1036e
xorl %eax, %eax
callq 0x35ee
movq 0x10(%rbx), %rdi
callq 0x253f
leaq 0xf9ff(%rip), %rdi      # 0x128bb
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f36
movl %edi, %eax
leaq 0xd192(%rip), %rcx      # 0x10088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd478(%rip), %rdi      # 0x1037e
jmp 0x2f2f
leaq 0xd49c(%rip), %rdi      # 0x103ab
xorl %eax, %eax
jmp 0x2030
leaq 0xd482(%rip), %rdi      # 0x1039f
jmp 0x2f2f
leaq 0xd47d(%rip), %rdi      # 0x103a3
jmp 0x2f2f
leaq 0xd46a(%rip), %rdi      # 0x10399
xorl %eax, %eax
jmp 0x2030
pushq %rax
leaq 0xf774(%rip), %rdi      # 0x126b2
leaq 0xd350(%rip), %rsi      # 0x10295
leaq 0xd46b(%rip), %rcx      # 0x103b7
movl $0xcd, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
orq %rsi, %rax
jne 0x2fc1
leaq 0xd44c(%rip), %rdi      # 0x10401
xorl %eax, %eax
callq 0x35ee
jmp 0x3090
leaq 0xd45b(%rip), %rdi      # 0x10423
xorl %eax, %eax
callq 0x3541
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2fe8
leaq 0xd458(%rip), %rdi      # 0x10437
xorl %eax, %eax
callq 0x2030
jmp 0x2ff2
movl $0xa, %edi
callq 0x2160
leaq 0x6(%rsp), %rdi
callq 0x34d0
leaq 0xd443(%rip), %rdi      # 0x10446
xorl %eax, %eax
callq 0x3541
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x3030
movq 0x28(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30dc
addq $0x8, %r12
cmpq %r12, %r14
jne 0x301e
leaq 0x6(%rsp), %rdi
callq 0x34e4
leaq 0x5(%rsp), %rdi
callq 0x34d0
leaq 0xd409(%rip), %rdi      # 0x10454
xorl %eax, %eax
callq 0x3541
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x3078
movq 0x40(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
callq 0x311e
addq $0x8, %r15
cmpq %r15, %r14
jne 0x3066
leaq 0x5(%rsp), %rdi
callq 0x34e4
leaq 0x100ca(%rip), %rdi     # 0x13153
xorl %eax, %eax
callq 0x3541
leaq 0x7(%rsp), %rdi
callq 0x34e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x30b3
jmp 0x30ae
jmp 0x30bd
jmp 0x30ae
movq %rax, %rbx
jmp 0x30ca
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x30c5
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x34e4
leaq 0x7(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x322f
leaq 0xd33d(%rip), %rdi      # 0x10489
xorl %eax, %eax
callq 0x3541
leaq 0xe(%rsp), %rdi
callq 0x34d0
leaq 0xd33c(%rip), %rdi      # 0x104a0
xorl %eax, %eax
callq 0x3541
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x3191
movq 0x30(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30dc
addq $0x8, %r12
cmpq %r12, %r14
jne 0x317f
leaq 0xe(%rsp), %rdi
callq 0x34e4
leaq 0xd(%rsp), %rdi
callq 0x34d0
leaq 0xd301(%rip), %rdi      # 0x104ad
xorl %eax, %eax
callq 0x3541
movq 0x58(%rbx), %r15
testq %r15, %r15
je 0x31ea
movq 0x60(%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x31e1
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x31c7
leaq 0xd(%rsp), %rdi
callq 0x34e4
leaq 0xc(%rsp), %rdi
callq 0x34d0
leaq 0xd2af(%rip), %rdi      # 0x104b4
xorl %eax, %eax
callq 0x3541
movq 0x68(%rbx), %rdi
callq 0x253f
leaq 0xc(%rsp), %rdi
callq 0x34e4
leaq 0xff2d(%rip), %rdi      # 0x13153
xorl %eax, %eax
callq 0x3541
jmp 0x323d
leaq 0xd22f(%rip), %rdi      # 0x10465
xorl %eax, %eax
callq 0x35ee
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3269
jmp 0x3278
jmp 0x3269
jmp 0x326e
jmp 0x3269
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x3280
movq %rax, %rbx
jmp 0x3285
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
jmp 0x3280
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
callq 0x34e4
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
movq 0x8(%rbx), %rsi
leaq 0xd205(%rip), %rdi      # 0x104bd
xorl %eax, %eax
callq 0x3541
leaq 0x6(%rsp), %rdi
callq 0x34d0
leaq 0xd1fc(%rip), %rdi      # 0x104cc
xorl %eax, %eax
callq 0x3541
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x32fd
movq 0x20(%rbx), %r15
shlq $0x3, %r14
xorl %r12d, %r12d
movq (%r15,%r12), %rdi
callq 0x30dc
addq $0x8, %r12
cmpq %r12, %r14
jne 0x32eb
leaq 0x6(%rsp), %rdi
callq 0x34e4
leaq 0x5(%rsp), %rdi
callq 0x34d0
leaq 0xd1d0(%rip), %rdi      # 0x104e8
xorl %eax, %eax
callq 0x3541
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x3346
movq 0x38(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r15, %r14
jne 0x3333
leaq 0x5(%rsp), %rdi
callq 0x34e4
leaq 0xfdfc(%rip), %rdi      # 0x13153
xorl %eax, %eax
callq 0x3541
leaq 0x7(%rsp), %rdi
callq 0x34e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3381
jmp 0x337c
jmp 0x338b
jmp 0x337c
movq %rax, %rbx
jmp 0x3398
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
jmp 0x3393
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0x34e4
leaq 0x7(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34d0
leaq 0x8(%rbx), %rdi
callq 0x3298
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x33ef
movq 0x58(%rbx), %rbx
shlq $0x3, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
callq 0x2f8c
addq $0x8, %r15
cmpq %r15, %r14
jne 0x33dd
leaq 0xf(%rsp), %rdi
callq 0x34e4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3405
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x34e4
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16537(%rip), %rax     # 0x19a38
cmpb $0x1, (%rax)
jne 0x353a
cmpl $0x2, 0x16173(%rip)     # 0x19680
jl 0x353a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xd072(%rip), %rbx      # 0x1058d
movl 0x16163(%rip), %esi     # 0x19684
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl 0x1614f(%rip), %eax     # 0x19680
addl $-0x2, %eax
incl %ebp
cmpl %eax, %ebp
jne 0x351b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3586
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 0x16492(%rip), %rax     # 0x19a38
cmpb $0x1, (%rax)
jne 0x35e3
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 0x34f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3630
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 0x163e8(%rip), %rax     # 0x19a38
cmpb $0x1, (%rax)
jne 0x368b
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 0x3541
movl $0xa, %edi
callq 0x2160
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/baziotis[P]minijava-cpp/./error.cpp
// Function: void warning<char const*>(char const*)
static void warning(Args... args) {
    log(loc);
    bold_on();
    printf(" Warning: ");
    bold_off();
    log(args...);
    printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x15ccb(%rip), %edx     # 0x19690
leaq 0x16074(%rip), %rax     # 0x19a40
movq (%rax), %rsi
leaq 0xd320(%rip), %rdi      # 0x10cf6
xorl %eax, %eax
callq 0x2030
leaq 0x16054(%rip), %r14     # 0x19a38
cmpb $0x1, 0x1(%r14)
jne 0x39f9
leaq 0xd30d(%rip), %rdi      # 0x10cff
xorl %eax, %eax
callq 0x2030
leaq 0xd304(%rip), %rdi      # 0x10d04
xorl %eax, %eax
callq 0x2030
cmpb $0x1, 0x1(%r14)
jne 0x3a1c
leaq 0xcaf0(%rip), %rdi      # 0x10505
xorl %eax, %eax
callq 0x2030
leaq 0xc991(%rip), %rdi      # 0x103b4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/baziotis[P]minijava-cpp/./error.cpp
// Function: void fatal_error<char const*, char, char const*, int>(char const*, char, char const*, int)
static void fatal_error(Args... args) {
	printf("Fatal error: ");
	log(args...);
	printf("\n");
    exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0xca8d(%rip), %rdi      # 0x10d0f
xorl %eax, %eax
callq 0x2030
leaq 0xc8a0(%rip), %rdi      # 0x10b30
leaq 0xc8b2(%rip), %rdx      # 0x10b49
movl %ebp, %esi
movl %ebx, %ecx
callq 0x46e0
movl $0xa, %edi
callq 0x2160
movl $0x1, %edi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x153d6(%rip), %xmm0    # 0x19698
movaps %xmm0, (%rsp)
movl 0x153c4(%rip), %ebx     # 0x19690
movq 0x153d5(%rip), %r14     # 0x196a8
callq 0x3a45
movl 0x153ba(%rip), %eax     # 0x19698
movq 0x153bb(%rip), %rdx     # 0x196a0
movq %r14, 0x153bc(%rip)     # 0x196a8
movl %ebx, 0x1539e(%rip)     # 0x19690
movaps (%rsp), %xmm0
movups %xmm0, 0x1539b(%rip)    # 0x19698
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x152c1(%rip), %rcx     # 0x196b0
leaq 0xc41a(%rip), %rdx      # 0x10810
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
movl %eax, %r8d
andl $0xf8, %r8d
cmpl $0x30, %r8d
jne 0x4414
orb $0x10, (%rax,%rcx)
movzbl %al, %r8d
addl $-0x41, %r8d
cmpl $0x25, %r8d
ja 0x442c
btq %r8, %rsi
jae 0x442c
orb $0x8, (%rax,%rcx)
leal -0x30(%rax), %r8d
cmpl $0x9, %r8d
ja 0x443a
orb $0xc, (%rax,%rcx)
movzbl %al, %r8d
addl $-0x9, %r8d
cmpl $0x75, %r8d
ja 0x445e
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
movb $0x2, %r8b
jmp 0x445a
movb $0x20, %r8b
orb %r8b, (%rax,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x4400
jmp 0x4470
movb $0x1, %r8b
jmp 0x445a
xorl %ecx, %ecx
leaq 0x15337(%rip), %rax     # 0x197b0
movw %cx, 0x60(%rax,%rcx,2)
incq %rcx
cmpq $0xa, %rcx
jne 0x4479
xorl %ecx, %ecx
leal 0xa(%rcx), %edx
movw %dx, 0xc2(%rax,%rcx,2)
incq %rcx
cmpq $0x6, %rcx
jne 0x4489
movl $0x1, 0x151e9(%rip)     # 0x19690
movq %rdi, 0x151fa(%rip)     # 0x196a8
jmp 0x3a45
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movl $0x2, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movl $0x1, (%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47df
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 0x15239(%rip), %rax     # 0x19a38
cmpb $0x1, 0x4(%rax)
jne 0x482f
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_O1/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 0x487c
leaq 0xc4be(%rip), %rsi      # 0x10d20
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 0x4899
cmpl $0x3c, %esi
jne 0x48b5
xorl %eax, %eax
cmpl %ecx, %edx
setl %al
movl %eax, %ecx
jmp 0x4899
subl %ecx, %edx
movl %edx, %ecx
jmp 0x4899
addl %edx, %ecx
jmp 0x4899
imull %edx, %ecx
movl $0x0, 0x10(%rdi)
movl $0x1, (%rdi)
movl %ecx, 0x18(%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xddf5(%rip), %rdi      # 0x126b2
leaq 0xc6c1(%rip), %rsi      # 0x10f85
leaq 0xc6c3(%rip), %rcx      # 0x10f8e
movl $0x67, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48fa
movl 0x18(%rax), %esi
testb %dil, %dil
je 0x490d
cmpl $0x1, %esi
je 0x491c
testl %esi, %esi
jne 0x492b
leaq 0xce60(%rip), %rdi      # 0x11758
jmp 0x4923
movq 0x18(%rax), %rsi
leaq 0xcdf3(%rip), %rdi      # 0x116f8
xorl %eax, %eax
popq %rcx
jmp 0x479d
leaq 0xd148(%rip), %rdi      # 0x11a5c
xorl %eax, %eax
popq %rcx
jmp 0x479d
leaq 0xce3b(%rip), %rdi      # 0x1175e
xorl %eax, %eax
popq %rcx
jmp 0x479d
leaq 0xce31(%rip), %rdi      # 0x11763
leaq 0xc64c(%rip), %rsi      # 0x10f85
leaq 0xcdee(%rip), %rcx      # 0x1172e
movl $0x74, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_print_stmt(llvalue_t)
void cgen_print_stmt(llvalue_t to_print) {
  print_codegen_indentation();
  emit("call void @print_int(i32 ");
  cgen_print_llvalue(to_print);
  emit(")\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x4, %ebp
leaq 0x20(%rsp), %r14
leaq 0xc77b(%rip), %rbx      # 0x110da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x479d
decl %ebp
jne 0x495f
leaq 0xc641(%rip), %rdi      # 0x10fb5
xorl %eax, %eax
callq 0x479d
movq 0x18(%r14), %rsi
cmpl $0x1, (%r14)
jne 0x4995
leaq 0xd0d0(%rip), %rdi      # 0x11a5c
xorl %eax, %eax
callq 0x479d
jmp 0x49a3
leaq 0xcd5c(%rip), %rdi      # 0x116f8
xorl %eax, %eax
callq 0x479d
leaq 0xe7a9(%rip), %rdi      # 0x13153
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x479d
// File: /workspace/github_cpp_makefile_star2_O1/baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_op(int, llvalue_t, llvalue_t)
llvalue_t llvm_op(int op, llvalue_t res1, llvalue_t res2) {
    if (res1.kind == LLVALUE::CONST && res2.kind == LLVALUE::CONST) {
        return llvm_op_const(op, res1.val, res2.val);
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl (%rdi), %r14d
movl %r14d, %eax
xorl $0x1, %eax
movl (%rsi), %edx
movl %edx, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
jne 0x49fa
movl 0x18(%rdi), %edx
movl 0x18(%rsi), %ecx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4853
jmp 0x4b24
movl %edx, 0x4(%rsp)
movq 0x15023(%rip), %rax     # 0x19a28
movq %rax, %rbp
incq %rax
movq %rax, 0x15016(%rip)     # 0x19a28
movl $0x4, %r13d
leaq 0xc6bb(%rip), %r12      # 0x110da
movq %r12, %rdi
xorl %eax, %eax
callq 0x479d
decl %r13d
jne 0x4a1f
leaq 0xc59a(%rip), %rdi      # 0x10fcf
movq %rbp, %rsi
xorl %eax, %eax
callq 0x479d
leal -0x26(%r15), %eax
cmpl $0x7, %eax
ja 0x4a61
leaq 0xc2f1(%rip), %rcx      # 0x10d40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc5a2(%rip), %rdi      # 0x11001
jmp 0x4a8d
cmpl $0x3c, %r15d
jne 0x4b36
leaq 0xc581(%rip), %rdi      # 0x10ff3
jmp 0x4a8d
leaq 0xc55d(%rip), %rdi      # 0x10fd8
jmp 0x4a8d
leaq 0xc55d(%rip), %rdi      # 0x10fe1
jmp 0x4a8d
leaq 0xc55d(%rip), %rdi      # 0x10fea
xorl %eax, %eax
callq 0x479d
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %rsi
cmpl $0x1, %r14d
jne 0x4ab3
leaq 0xcfb2(%rip), %rdi      # 0x11a5c
xorl %eax, %eax
callq 0x479d
jmp 0x4ac1
leaq 0xcc3e(%rip), %rdi      # 0x116f8
xorl %eax, %eax
callq 0x479d
leaq 0xe2f7(%rip), %rdi      # 0x12dbf
xorl %eax, %eax
callq 0x479d
leaq 0x60(%rsp), %rax
movq 0x18(%rax), %rsi
cmpl $0x1, 0x4(%rsp)
jne 0x4aef
leaq 0xcf76(%rip), %rdi      # 0x11a5c
xorl %eax, %eax
callq 0x479d
jmp 0x4afd
leaq 0xcc02(%rip), %rdi      # 0x116f8
xorl %eax, %eax
callq 0x479d
leaq 0xca14(%rip), %rdi      # 0x11518
xorl %eax, %eax
callq 0x479d
movl $0x0, 0x10(%rbx)
movl $0x2, (%rbx)
movq %rbp, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdb75(%rip), %rdi      # 0x126b2
leaq 0xc441(%rip), %rsi      # 0x10f85
leaq 0xc4be(%rip), %rcx      # 0x11009
movl $0x9f, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b55
leaq 0xc4b3(%rip), %rdi      # 0x11061
xorl %eax, %eax
callq 0x479d
cmpq $0x0, 0x10(%rbx)
je 0x4bca
leaq 0xe1fc(%rip), %rdi      # 0x12dbf
xorl %eax, %eax
callq 0x479d
cmpq $0x0, 0x10(%rbx)
je 0x4c0b
leaq 0xe1e7(%rip), %r14      # 0x12dbf
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
callq 0x4b55
movq 0x10(%rbx), %rax
decq %rax
cmpq %rax, %r15
je 0x4c02
movq %r14, %rdi
xorl %eax, %eax
callq 0x479d
incq %r15
cmpq 0x10(%rbx), %r15
jne 0x4bdb
leaq 0xc455(%rip), %rdi      # 0x11067
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x479d