LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_load(Type*, llvalue_t)
llvalue_t llvm_load(Type *type, llvalue_t ptr) {
    assert(ptr.kind == LLVALUE::REG);
    llvalue_t v;
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    switch (type->kind) {
    case TY::BOOL:
    {
        emit("%%%ld = load i1, i1* %%%ld\n", v.reg, ptr.reg);
    } break;
    case TY::INT:
    {
        emit("%%%ld = load i32, i32* %%%ld, align 4\n", v.reg, ptr.reg);
    } break;
    case TY::ARR:
    {
        emit("%%%ld = load i32*, i32** %%%ld, align 8\n", v.reg, ptr.reg);
    } break;
    case TY::ID:
    {
        emit("%%%ld = load i8*, i8** %%%ld\n", v.reg, ptr.reg);
    } break;
    default: assert(0);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
cmpl $0x2, (%rax)
jne 0x69c3
jmp 0x69e2
leaq 0x13a1f(%rip), %rdi     # 0x1a3e9
leaq 0x137e0(%rip), %rsi     # 0x1a1b1
movl $0x13a, %edx            # imm = 0x13A
leaq 0x13bf5(%rip), %rcx     # 0x1a5d2
callq 0x20d0
movq -0x20(%rbp), %rdi
callq 0x7840
callq 0x5a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x2, (%rax)
callq 0x5f30
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x6ab2
movq -0x28(%rbp), %rax
leaq 0x13583(%rip), %rcx     # 0x19fac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13bb0(%rip), %rdi     # 0x1a5f9
movb $0x0, %al
callq 0x5b70
jmp 0x6ad1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13bac(%rip), %rdi     # 0x1a615
movb $0x0, %al
callq 0x5b70
jmp 0x6ad1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13bb3(%rip), %rdi     # 0x1a63c
movb $0x0, %al
callq 0x5b70
jmp 0x6ad1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x138b8(%rip), %rdi     # 0x1a361
movb $0x0, %al
callq 0x5b70
jmp 0x6ad1
leaq 0x14ec9(%rip), %rdi     # 0x1b982
leaq 0x136f1(%rip), %rsi     # 0x1a1b1
movl $0x150, %edx            # imm = 0x150
leaq 0x13b06(%rip), %rcx     # 0x1a5d2
callq 0x20d0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: not_llvalue(llvalue_t)
llvalue_t not_llvalue(llvalue_t v) {
    assert(v.kind == LLVALUE::REG);
    long reg = gen_reg();
    print_codegen_indentation();
    emit("%%%ld = icmp eq i1 %%%ld, 0\n", reg, v.reg);
    v.reg = reg;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x2, (%rax)
jne 0x6aff
jmp 0x6b1e
leaq 0x13b5f(%rip), %rdi     # 0x1a665
leaq 0x136a4(%rip), %rsi     # 0x1a1b1
movl $0x156, %edx            # imm = 0x156
leaq 0x13b63(%rip), %rcx     # 0x1a67c
callq 0x20d0
callq 0x5a40
movq %rax, -0x8(%rbp)
callq 0x5f30
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x18(%rax), %rdx
leaq 0x13b5e(%rip), %rdi     # 0x1a69d
movb $0x0, %al
callq 0x5b70
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rsi
movq %rsi, 0x18(%rdx)
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_calloc(llvalue_t)
llvalue_t llvm_calloc(llvalue_t sz) {
    llvalue_t v = register_llv(gen_reg(), {});
    print_codegen_indentation();
    if (sz.kind == LLVALUE::CONST) {
        emit("%%%ld = call noalias i8* @calloc(i32 1, i32 %d)\n", v.reg, sz.val);
    } else {
        emit("%%%ld = call noalias i8* @calloc(i32 1, i32 %%%ld)\n", v.reg, sz.reg);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x5a40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rdx
movl -0x8(%rbp), %ecx
callq 0x5ad0
callq 0x5f30
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6bec
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movl 0x18(%rax), %edx
leaq 0x13ad7(%rip), %rdi     # 0x1a6ba
movb $0x0, %al
callq 0x5b70
jmp 0x6c0a
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdx
leaq 0x13ae8(%rip), %rdi     # 0x1a6eb
movb $0x0, %al
callq 0x5b70
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_branch_cond(llvalue_t, llvm_label_t, llvm_label_t)
void llvm_branch_cond(llvalue_t cond, llvm_label_t l1, llvm_label_t l2) {
    print_codegen_indentation();
    emit("br i1 ");
    cgen_print_llvalue(cond);
    emit(", label %%%s, label %%%s\n\n", l1.lbl, l2.lbl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5f30
leaq 0x13ab0(%rip), %rdi     # 0x1a724
movb $0x0, %al
callq 0x5b70
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x13a51(%rip), %rdi     # 0x1a72b
movb $0x0, %al
callq 0x5b70
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_phi_node(Type*, llvalue_t, llvalue_t, llvm_label_t, llvm_label_t, long)
llvalue_t llvm_phi_node(Type *type, llvalue_t val1,
                    llvalue_t val2, llvm_label_t lbl1,
                    llvm_label_t lbl2, long reg) {
    llvalue_t phi_value;
    phi_value.kind = LLVALUE::REG;
    if (reg == -1) {
        phi_value.reg = gen_reg();
    } else {
        phi_value.reg = reg;
    }
    print_codegen_indentation();
    emit("%%%ld = phi ", phi_value.reg);
    cgen_print_lltype(type);
    emit(" [ ");
    cgen_print_llvalue(val1);
    emit(", %%%s ], [ ", lbl1.lbl);
    cgen_print_llvalue(val2);
    emit(", %%%s ]\n", lbl2.lbl);
    return phi_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %r8, -0x20(%rbp)
callq 0x7840
movq -0x68(%rbp), %rdi
movl $0x2, (%rdi)
cmpq $-0x1, -0x20(%rbp)
jne 0x6d7e
callq 0x5a40
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x6d8a
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
callq 0x5f30
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x139b8(%rip), %rdi     # 0x1a756
movb $0x0, %al
callq 0x5b70
movq -0x18(%rbp), %rdi
callq 0x6170
leaq 0x139b7(%rip), %rdi     # 0x1a76c
movb $0x0, %al
callq 0x5b70
movq -0x70(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
movq -0x8(%rbp), %rsi
leaq 0x1394c(%rip), %rdi     # 0x1a763
movb $0x0, %al
callq 0x5b70
movq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x60(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
movq -0x10(%rbp), %rsi
leaq 0x138f7(%rip), %rdi     # 0x1a770
movb $0x0, %al
callq 0x5b70
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_alloca(Type*)
llvalue_t llvm_alloca(Type *type) {
    llvalue_t v;
    v.reg = gen_reg();
    v.kind = LLVALUE::REG;
    print_codegen_indentation();
    switch (type->kind) {
    case TY::BOOL:
    {
        emit("%%%ld = alloca i1\n", v.reg);
    } break;
    case TY::INT:
    {
        emit("%%%ld = alloca i32, align 4\n", v.reg);
    } break;
    case TY::ARR:
    {
        emit("%%%ld = alloca i32*, align 8\n", v.reg);
    } break;
    case TY::ID:
    {
        IdType *idtype = (IdType*) type;
        assert(idtype->is_IdType());
        emit("%%%ld = alloca %%class.%s*, align 8\n", v.reg, idtype->id);
    } break;
    // We don't actually want to assert here because we might have an undefined
    // type. The error has been issued elsewhere.
    default: break;
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
callq 0x7840
callq 0x5a40
movq -0x20(%rbp), %rdi
movq %rax, 0x18(%rdi)
movl $0x2, (%rdi)
callq 0x5f30
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x71f3
movq -0x18(%rbp), %rax
leaq 0x12e75(%rip), %rcx     # 0x19fbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x136c8(%rip), %rdi     # 0x1a827
movb $0x0, %al
callq 0x5b70
jmp 0x71f5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x136c0(%rip), %rdi     # 0x1a83a
movb $0x0, %al
callq 0x5b70
jmp 0x71f5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x136c5(%rip), %rdi     # 0x1a857
movb $0x0, %al
callq 0x5b70
jmp 0x71f5
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7960
cmpq $0x0, %rax
je 0x71b4
jmp 0x71d3
leaq 0x136ba(%rip), %rdi     # 0x1a875
leaq 0x12fef(%rip), %rsi     # 0x1a1b1
movl $0x1c6, %edx            # imm = 0x1C6
leaq 0x136bb(%rip), %rcx     # 0x1a889
callq 0x20d0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x136bd(%rip), %rdi     # 0x1a8a7
movb $0x0, %al
callq 0x5b70
jmp 0x71f5
jmp 0x71f5
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_store(Type*, llvalue_t, llvalue_t)
void llvm_store(Type *type, llvalue_t value, llvalue_t ptr) {
    assert(ptr.kind == LLVALUE::REG);
    print_codegen_indentation();
    emit("store ");
    cgen_print_lltype(type);
    emit(" ");
    cgen_print_llvalue(value);
    emit(", ");
    cgen_print_lltype(type);
    emit("* ");
    cgen_print_llvalue(ptr);
    emit("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, (%rax)
jne 0x7226
jmp 0x7245
leaq 0x131bc(%rip), %rdi     # 0x1a3e9
leaq 0x12f7d(%rip), %rsi     # 0x1a1b1
movl $0x1d1, %edx            # imm = 0x1D1
leaq 0x1368c(%rip), %rcx     # 0x1a8cc
callq 0x20d0
callq 0x5f30
leaq 0x136a9(%rip), %rdi     # 0x1a8fa
movb $0x0, %al
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x6170
leaq 0x1309e(%rip), %rdi     # 0x1a306
movb $0x0, %al
callq 0x5b70
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x14ddc(%rip), %rdi     # 0x1c0a2
movb $0x0, %al
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x6170
leaq 0x13028(%rip), %rdi     # 0x1a305
movb $0x0, %al
callq 0x5b70
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x13409(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x5b70
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: cgen_cast_value(llvalue_t, Type*, Type*)
llvalue_t cgen_cast_value(llvalue_t value, Type *from_ty, Type *to_ty) {
    long reg = gen_reg();
    print_codegen_indentation();
    emit("%%%ld = bitcast ", reg);
    cgen_print_lltype(from_ty);
    emit(" ");
    cgen_print_llvalue(value);
    emit(" to ");
    cgen_print_lltype(to_ty);
    emit("\n");
    value.kind = LLVALUE::REG;
    value.reg = reg;
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x5a40
movq %rax, -0x18(%rbp)
callq 0x5f30
movq -0x18(%rbp), %rsi
leaq 0x132db(%rip), %rdi     # 0x1a944
movb $0x0, %al
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x6170
leaq 0x12c86(%rip), %rdi     # 0x1a306
movb $0x0, %al
callq 0x5b70
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x12cba(%rip), %rdi     # 0x1a398
movb $0x0, %al
callq 0x5b70
movq -0x10(%rbp), %rdi
callq 0x6170
leaq 0x1304f(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x5b70
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movl $0x2, (%rcx)
movq -0x18(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rdi)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/llvm.cpp
// Function: llvm_ret(Type*, llvalue_t)
void llvm_ret(Type *ty, llvalue_t val) {
    print_codegen_indentation();
    emit("ret ");
    cgen_print_lltype(ty);
    emit(" ");
    cgen_print_llvalue(val);
    emit("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x5f30
leaq 0x131f5(%rip), %rdi     # 0x1a955
movb $0x0, %al
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x6170
leaq 0x12b8f(%rip), %rdi     # 0x1a306
movb $0x0, %al
callq 0x5b70
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rax
xorl %edi, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5d40
leaq 0x12f6f(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x5b70
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: baziotis[P]minijava-cpp/main.cpp
// Function: parse_and_return_goal()
Goal parse_and_return_goal() {
    std::ifstream input_file(filename);
    if (!input_file.good()) {
        assert(0);
    }
    std::stringstream sstr;
    sstr << input_file.rdbuf();
    std::string file_contents_str = sstr.str();
    input_file.close();

    const char *file_contents = file_contents_str.c_str();

    parse_init(file_contents, filename);
    Goal goal = parse_goal();
    return goal;
    // Here `file_contents_str` memory gets deallocated because
    // of destructor.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rdi, -0x3e0(%rbp)
movq %rdi, -0x3d8(%rbp)
movq 0x1d010(%rip), %rsi     # 0x24a50
leaq -0x208(%rbp), %rdi
movl $0x8, %edx
callq 0x21d0
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x21b0
movb %al, -0x3c9(%rbp)
jmp 0x7a71
movb -0x3c9(%rbp), %al
testb $0x1, %al
jne 0x7ab3
jmp 0x7a7d
leaq 0x13efe(%rip), %rdi     # 0x1b982
leaq 0x13004(%rip), %rsi     # 0x1aa8f
movl $0x18, %edx
leaq 0x13001(%rip), %rcx     # 0x1aa98
callq 0x20d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x7bc4
leaq -0x3a0(%rbp), %rdi
callq 0x20e0
jmp 0x7ac1
leaq -0x390(%rbp), %rax
movq %rax, -0x3f0(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x2190
movq %rax, -0x3e8(%rbp)
jmp 0x7ae4
movq -0x3e8(%rbp), %rsi
movq -0x3f0(%rbp), %rdi
callq 0x2060
jmp 0x7af9
leaq -0x3c0(%rbp), %rdi
leaq -0x3a0(%rbp), %rsi
callq 0x2110
jmp 0x7b0e
leaq -0x208(%rbp), %rdi
callq 0x2050
jmp 0x7b1c
leaq -0x3c0(%rbp), %rdi
callq 0x2080
movq %rax, -0x3c8(%rbp)
movq -0x3c8(%rbp), %rdi
movq 0x1cf13(%rip), %rsi     # 0x24a50
callq 0x8260
jmp 0x7b44
movq -0x3e0(%rbp), %rdi
callq 0x7d20
jmp 0x7b52
leaq -0x3c0(%rbp), %rdi
callq 0x20c0
leaq -0x3a0(%rbp), %rdi
callq 0x20f0
leaq -0x208(%rbp), %rdi
callq 0x2070
movq -0x3d8(%rbp), %rax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x7bb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x3c0(%rbp), %rdi
callq 0x20c0
leaq -0x3a0(%rbp), %rdi
callq 0x20f0
leaq -0x208(%rbp), %rdi
callq 0x2070
movq -0x210(%rbp), %rdi
callq 0x21c0
nopl (%rax)
// File: baziotis[P]minijava-cpp/main.cpp
// Function: main
int main(int argc, char **argv) {
    filename = argv[1];

    config.log = false;
    config.ansi_style = true;
    config.unused = true;
    config.offsets = false;
    config.codegen = false;

    for (int i = 1; i != argc; ++i) {
        if (!strcmp(argv[i], "-v")) {
            config.log = true;
        }
        if (!strcmp(argv[i], "-unused")) {
            config.unused = false;
        }
        if (!strcmp(argv[i], "-no-style")) {
            config.ansi_style = false;
        }
        if (!strcmp(argv[i], "-offsets")) {
            config.offsets = true;
        }
        if (!strcmp(argv[i], "-codegen")) {
            config.codegen = true;
        }
    }

    Goal goal = parse_and_return_goal();

    // TODO: Check for fatal parsing errors here and don't continue
    // if they exist.
    
    typecheck(&goal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x1ce48(%rip)     # 0x24a50
movb $0x0, 0x1ce39(%rip)     # 0x24a48
movb $0x1, 0x1ce33(%rip)     # 0x24a49
movb $0x1, 0x1ce2d(%rip)     # 0x24a4a
movb $0x0, 0x1ce27(%rip)     # 0x24a4b
movb $0x0, 0x1ce21(%rip)     # 0x24a4c
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x7d02
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x12e64(%rip), %rsi     # 0x1aab5
callq 0x2170
cmpl $0x0, %eax
jne 0x7c62
movb $0x1, 0x1cde6(%rip)     # 0x24a48
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x12e43(%rip), %rsi     # 0x1aab8
callq 0x2170
cmpl $0x0, %eax
jne 0x7c86
movb $0x0, 0x1cdc4(%rip)     # 0x24a4a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x12e27(%rip), %rsi     # 0x1aac0
callq 0x2170
cmpl $0x0, %eax
jne 0x7caa
movb $0x0, 0x1cd9f(%rip)     # 0x24a49
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x12e0d(%rip), %rsi     # 0x1aaca
callq 0x2170
cmpl $0x0, %eax
jne 0x7cce
movb $0x1, 0x1cd7d(%rip)     # 0x24a4b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x12df2(%rip), %rsi     # 0x1aad3
callq 0x2170
cmpl $0x0, %eax
jne 0x7cf2
movb $0x1, 0x1cd5a(%rip)     # 0x24a4c
jmp 0x7cf4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c32
leaq -0x78(%rbp), %rdi
callq 0x7a20
leaq -0x78(%rbp), %rdi
callq 0xcac0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_goal()
Goal parse_goal() {
    Goal goal;
    goal.main_class = parse_main_class();
    if (goal.main_class.is_undefined()) {
        fatal_error("Main Class had errors that can't be recovered.");
    }
    while (is_token(TOK::CLASS)) {
        TypeDeclaration *type_decl = parse_type_declaration();
        if (!type_decl->is_undefined()) {
            goal.type_decls.push(type_decl);
        }
    }
    return goal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0xa9e0
leaq -0x40(%rbp), %rdi
callq 0x7dc0
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movl $0x40, %edx
callq 0x2100
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0xaa10
testb $0x1, %al
jne 0x7d6a
jmp 0x7d76
leaq 0x12de3(%rip), %rdi     # 0x1ab54
callq 0x8030
jmp 0x7d78
movl $0x16, %edi
callq 0x8070
testb $0x1, %al
jne 0x7d88
jmp 0x7db1
callq 0x8090
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3a30
testb $0x1, %al
jne 0x7daf
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movq -0x48(%rbp), %rsi
callq 0xaa30
jmp 0x7d78
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_init(char const*, char const*)
void parse_init(const char *file_contents, const char *filename) {
    lexer_init(file_contents, filename);
    // TODO: Move this to some general initialization.
    EOI_has_been_found = false;
    main_method_string = str_intern("main");
    length_ = str_intern("length");
    set_indent_char('-');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x52b0
movb $0x0, 0x1c7dc(%rip)     # 0x24a60
leaq 0x128f8(%rip), %rdi     # 0x1ab83
callq 0xbae0
movq %rax, 0x1c7c1(%rip)     # 0x24a58
leaq 0x128ea(%rip), %rdi     # 0x1ab88
callq 0xbae0
movq %rax, 0x1c7be(%rip)     # 0x24a68
movl $0x2d, %edi
callq 0x3fd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: match_token(TOK)
static bool match_token(TOK kind) {
    if (is_token(kind)) {
        next_token();
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x8070
testb $0x1, %al
jne 0x82d9
jmp 0x82e4
callq 0x4370
movb $0x1, -0x1(%rbp)
jmp 0x82e8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: expect_token_in_rule(TOK, char const*, bool)
static bool expect_token_in_rule(TOK kind, const char *rule, bool advance = false) {
    if (EOI_has_been_found) return false;
    if (is_token(TOK::EOI)) {
        EOI_has_been_found = true;
    }
    bool res;
    if (is_token(kind)) {
        next_token();
        return true;
    } else {
        syntax_error("Expected `", kind, "` in: ", rule, ", found `", token, "`");
        res = false;
    }
    if (advance) {
        next_token();
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, 0x1c743(%rip)     # 0x24a60
je 0x8328
movb $0x0, -0x1(%rbp)
jmp 0x83c1
movl $0x1, %edi
callq 0x8070
testb $0x1, %al
jne 0x8338
jmp 0x833f
movb $0x1, 0x1c721(%rip)     # 0x24a60
movl -0x8(%rbp), %edi
callq 0x8070
testb $0x1, %al
jne 0x834d
jmp 0x8358
callq 0x4370
movb $0x1, -0x1(%rbp)
jmp 0x83c1
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq 0x1c342(%rip), %rax     # 0x246a8
movq (%rax), %rdx
movq %rdx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x12989(%rip), %rdi     # 0x1ad05
leaq 0x1298d(%rip), %rdx     # 0x1ad10
leaq 0x12a16(%rip), %r8      # 0x1ada0
leaq -0x28(%rbp), %rax
leaq 0x12998(%rip), %r9      # 0x1ad2d
movq (%rax), %r10
movq %r10, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x86c0
movb $0x0, -0x12(%rbp)
testb $0x1, -0x11(%rbp)
je 0x83b9
callq 0x4370
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: skip_tokens(TOK, bool)
static void skip_tokens(TOK kind, bool eat = true) {
    int num_errors = 0;
    constexpr int lim = 5;
    TOK last;
    while (!is_token(TOK::EOI) && token.kind != kind) {
        if (num_errors == 0) {
            printf(";  skipping ");
        }
        ++num_errors;
        if (num_errors < lim) {
            if (num_errors > 1) {
                printf(", ");
            }
            log("`", token, "`");
        }
        last = token.kind;
        next_token();
    }
    if (eat) {
        next_token();
    }
    if (num_errors >= lim) {
        log(" ... `", last, "`");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movl $0x1, %edi
callq 0x8070
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x8499
leaq 0x1c21a(%rip), %rax     # 0x246a8
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x84a2
jmp 0x851b
cmpl $0x0, -0xc(%rbp)
jne 0x84b6
leaq 0x1286c(%rip), %rdi     # 0x1ad1b
movb $0x0, %al
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x8505
cmpl $0x1, -0xc(%rbp)
jle 0x84d9
leaq 0x13bd0(%rip), %rdi     # 0x1c0a2
movb $0x0, %al
callq 0x2030
leaq 0x1c1c8(%rip), %rax     # 0x246a8
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x12830(%rip), %rcx     # 0x1ad2d
movq %rcx, %rdi
callq 0x8ac0
leaq 0x1c19c(%rip), %rax     # 0x246a8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x4370
jmp 0x8471
testb $0x1, -0x5(%rbp)
je 0x8526
callq 0x4370
cmpl $0x5, -0xc(%rbp)
jl 0x8542
movl -0x14(%rbp), %esi
leaq 0x127f2(%rip), %rdi     # 0x1ad28
leaq 0x127f0(%rip), %rdx     # 0x1ad2d
callq 0x8bc0
leaq 0x121fb(%rip), %rdi     # 0x1a744
movb $0x0, %al
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: starts_local()
static bool starts_local() {
    if (!starts_type(token.kind)) {
        return false;
    } else if (is_token(TOK::ID)) {
        // A little bit of hackiness:
        // An identifer can start both a statement
        // and a type. So, you have to peek a token
        // and see. The logic of peeking
        // is hidden in the lexer.
        token_t save_token = peek_token();
        if (save_token.kind == TOK::ASGN ||
            save_token.kind == TOK::LBRACKET)
        {
            return false;
        }
        return true;
    } else {
        return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1c139(%rip), %rax     # 0x246a8
movl (%rax), %edi
callq 0x8c20
testb $0x1, %al
jne 0x8580
movb $0x0, -0x1(%rbp)
jmp 0x85b8
movl $0x8, %edi
callq 0x8070
testb $0x1, %al
jne 0x8590
jmp 0x85b4
callq 0x50b0
movl %eax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x18, -0x18(%rbp)
je 0x85a8
cmpl $0x24, -0x18(%rbp)
jne 0x85ae
movb $0x0, -0x1(%rbp)
jmp 0x85b8
movb $0x1, -0x1(%rbp)
jmp 0x85b8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/./error.cpp
// Function: log(token_t)
static void log(token_t tok) {
    printf("%s", token_name(tok.kind));
    if (tok.kind == TOK::INTLIT) {
        printf(" %d", tok.val);
    } else if (tok.kind == TOK::ID) {
        printf(" %s", tok.id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %edi
callq 0xbb40
movq %rax, %rsi
leaq 0x1087a(%rip), %rdi     # 0x193eb
movb $0x0, %al
callq 0x2030
cmpl $0x2, -0x10(%rbp)
jne 0x8b91
movl -0x8(%rbp), %esi
leaq 0x1218f(%rip), %rdi     # 0x1ad17
movb $0x0, %al
callq 0x2030
jmp 0x8bab
cmpl $0x8, -0x10(%rbp)
jne 0x8ba9
movq -0x8(%rbp), %rsi
leaq 0x10848(%rip), %rdi     # 0x193ea
movb $0x0, %al
callq 0x2030
jmp 0x8bab
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_local()
static LocalDeclaration *parse_local() {
    LocalDeclaration *local = new LocalDeclaration;
    local->loc = loc;
    if (!starts_local()) {
        syntax_error("Expected start of type specifier"
                     " (`int` or `boolean`), to start local declaration",
                     " (either parameter or variable), found `", token, "`");
        goto Lerror;
    }
    local->typespec = parse_typespec();
    if (local->typespec.kind == TYSPEC::UNDEFINED) {
        goto Lerror;
    }
    local->id = token.id;
    if (!match_token(TOK::ID)) {
        syntax_error_no_ln("Expected Identifier after type specifier `");
        typespec_print(local->typespec);
        printf("`");
        log(", found `", token, "`\n");
        next_token();
        goto Lerror;
    }
    return local;
Lerror:
    local->make_undefined();
    return local;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x20, %edi
callq 0xabf0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0xac10
jmp 0x8c73
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1ba1a(%rip), %rcx     # 0x246a0
movl (%rcx), %ecx
movl %ecx, (%rax)
callq 0x8560
testb $0x1, %al
jne 0x8cee
leaq 0x1ba0e(%rip), %rax     # 0x246a8
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %edx
movq -0x28(%rbp), %rcx
leaq 0x12078(%rip), %rdi     # 0x1ad2f
leaq 0x120c3(%rip), %rsi     # 0x1ad81
leaq 0x12068(%rip), %r8      # 0x1ad2d
callq 0x8de0
jmp 0x8db9
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x2120
jmp 0x8dd4
callq 0x8e40
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x8d1d
jmp 0x8db9
leaq 0x1b984(%rip), %rax     # 0x246a8
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x8, %edi
callq 0x82c0
testb $0x1, %al
jne 0x8daf
leaq 0x12065(%rip), %rdi     # 0x1adaa
callq 0x8400
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %edi
movq -0x48(%rbp), %rsi
callq 0x3040
leaq 0x11fbc(%rip), %rdi     # 0x1ad2d
movb $0x0, %al
callq 0x2030
leaq 0x1b929(%rip), %rax     # 0x246a8
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x60(%rbp), %esi
movq -0x58(%rbp), %rdx
leaq 0x12004(%rip), %rdi     # 0x1ada0
leaq 0x12a36(%rip), %rcx     # 0x1b7d9
callq 0x8ac0
callq 0x4370
jmp 0x8db9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8dca
movq -0x10(%rbp), %rdi
callq 0xac30
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x21c0
nopl (%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_typespec()
static Typespec parse_typespec() {
    Typespec tspec;
    tspec.kind = TYSPEC::UNDEFINED;
    // The contract is that if the caller called this function,
    // then a type _must_ follow. In other words, the caller
    // is responsible to check whether a type follows.
    // The caller is also responsible for checking whether
    // an TYSPEC::UNDEFINED was returned.
    if (!starts_type(token.kind)) {
        syntax_error("Expected start of type specifier"
                     " (`int` or `boolean`), found ", token);
        return tspec;
    }
    switch (token.kind) {
    case TOK::INT:
    {
        next_token();
        if (match_token(TOK::LBRACKET)) {
            expect_token_in_rule(TOK::RBRACKET, "int array type specifier");
            tspec.kind = TYSPEC::ARR;
        } else {
            tspec.kind = TYSPEC::INT;
        }
    } break;
    case TOK::BOOLEAN:
    {
        next_token();
        tspec.kind = TYSPEC::BOOL;
        if (match_token(TOK::LBRACKET)) {
            syntax_error("You can't have arrays of `boolean` type, only of `int`.");
            match_token(TOK::RBRACKET);
        }
    } break;
    case TOK::ID:
    {
        tspec.id = token.id;
        tspec.kind = TYSPEC::ID;
        next_token();
    } break;
    default: tspec.kind = TYSPEC::UNDEFINED;
    }
    // The caller is responsible for recognizing
    // an UNDEFINED type specifier and issuing
    // a message.
    return tspec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x10(%rbp)
leaq 0x1b852(%rip), %rax     # 0x246a8
movl (%rax), %edi
callq 0x8c20
testb $0x1, %al
jne 0x8e8f
leaq 0x1b840(%rip), %rax     # 0x246a8
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x11f50(%rip), %rdi     # 0x1add5
callq 0x8fe0
jmp 0x8f4d
leaq 0x1b812(%rip), %rax     # 0x246a8
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x5, %eax
je 0x8ef3
jmp 0x8ea2
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x8eb9
jmp 0x8eac
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x8f27
jmp 0x8f44
callq 0x4370
movl $0x24, %edi
callq 0x82c0
testb $0x1, %al
jne 0x8ece
jmp 0x8eea
movl $0x1b, %edi
leaq 0x11f39(%rip), %rsi     # 0x1ae13
xorl %edx, %edx
callq 0x8300
movl $0x1, -0x10(%rbp)
jmp 0x8ef1
movl $0x2, -0x10(%rbp)
jmp 0x8f4b
callq 0x4370
movl $0x3, -0x10(%rbp)
movl $0x24, %edi
callq 0x82c0
testb $0x1, %al
jne 0x8f0f
jmp 0x8f25
leaq 0x11f16(%rip), %rdi     # 0x1ae2c
callq 0x83d0
movl $0x1b, %edi
callq 0x82c0
jmp 0x8f4b
leaq 0x1b77a(%rip), %rax     # 0x246a8
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x4, -0x10(%rbp)
callq 0x4370
jmp 0x8f4b
movl $0x0, -0x10(%rbp)
jmp 0x8f4d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_stmt_block()
static Buf<Statement*> parse_stmt_block() {
    Buf<Statement*> stmts;
    while (!is_token(TOK::RBRACE)) {
        parse_stmt_and_push(&stmts);
    }
    return stmts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
callq 0xab20
movl $0x1a, %edi
callq 0x8070
xorb $-0x1, %al
testb $0x1, %al
jne 0x98ba
jmp 0x98c5
movq -0x10(%rbp), %rdi
callq 0x8640
jmp 0x98a8
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: expect_token(TOK, bool)
static bool expect_token(TOK kind, bool advance = false) {
    if (EOI_has_been_found) return false;
    if (is_token(TOK::EOI)) {
        EOI_has_been_found = true;
    }
    bool res;
    if (is_token(kind)) {
        next_token();
        return true;
    } else {
        syntax_error("Expected `", kind, "`, found `", token, "`");
        res = false;
    }
    if (advance) {
        next_token();
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, 0x1b176(%rip)     # 0x24a60
je 0x98f5
movb $0x0, -0x1(%rbp)
jmp 0x9976
movl $0x1, %edi
callq 0x8070
testb $0x1, %al
jne 0x9905
jmp 0x990c
movb $0x1, 0x1b154(%rip)     # 0x24a60
movl -0x8(%rbp), %edi
callq 0x8070
testb $0x1, %al
jne 0x991a
jmp 0x9925
callq 0x4370
movb $0x1, -0x1(%rbp)
jmp 0x9976
movl -0x8(%rbp), %esi
leaq 0x1ad79(%rip), %rax     # 0x246a8
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq 0x113b9(%rip), %rdi     # 0x1ad05
leaq 0x11767(%rip), %rdx     # 0x1b0ba
leaq 0x113d3(%rip), %r9      # 0x1ad2d
callq 0x9e30
movb $0x0, -0xa(%rbp)
testb $0x1, -0x9(%rbp)
je 0x996e
callq 0x4370
movb -0xa(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_expr_clause()
static Expression *parse_expr_clause() {
    Expression *expr;
    if (match_token(TOK::NOT)) {
        expr = new Expression;
        expr->loc = loc;
        expr->kind = EXPR::NOT;
        expr->e1 = parse_expr_clause();
    } else {
        expr = parse_expr_primary();
    }
    return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
callq 0x82c0
testb $0x1, %al
jne 0x9fe8
jmp 0xa022
movl $0x18, %edi
callq 0xae40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1a69f(%rip), %rcx     # 0x246a0
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x4(%rax)
callq 0x9fd0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa02b
callq 0xa0f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: baziotis[P]minijava-cpp/parse.cpp
// Function: parse_expr_list()
static Buf<Expression*> parse_expr_list() {
    Buf<Expression*> expr_list;
    if (is_token(TOK::RPAR)) {
        return expr_list;
    }
    while (true) {
        expr_list.push(parse_expr());
        if (!is_token(TOK::RPAR)) {
            if (!match_token(TOK::COMMA)) {
                syntax_error("Expected `,` in expression list.");
                break;
            }
        } else {
            break;
        }
    }
    return expr_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
callq 0xb080
movl $0x19, %edi
callq 0x8070
testb $0x1, %al
jne 0xa098
jmp 0xa09a
jmp 0xa0df
jmp 0xa09c
callq 0x9990
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0xb0b0
movl $0x19, %edi
callq 0x8070
testb $0x1, %al
jne 0xa0d9
movl $0x1c, %edi
callq 0x82c0
testb $0x1, %al
jne 0xa0d7
leaq 0x11096(%rip), %rdi     # 0x1b166
callq 0x83d0
jmp 0xa0dd
jmp 0xa0db
jmp 0xa0dd
jmp 0xa09c
jmp 0xa0df
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./buf.h
// Function: Buf<TypeDeclaration*>::push(TypeDeclaration*)
void push(T v) {
        size_t new_len = len + 1;
        if(new_len > cap) _grow(new_len);
        data[len] = v;
        len = new_len;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jbe 0xaa6a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb750
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/./buf.h
// Function: Buf<LocalDeclaration*>::_grow(unsigned long)
void _grow(size_t new_len) {
        constexpr size_t size_t_max = std::numeric_limits<size_t>::max();
        assert(cap <= (size_t_max - 1) / 2);
        size_t new_cap = MAX(MAX(2*cap, new_len), 16);
        assert(new_len <= new_cap);
        assert(new_cap <= (size_t_max) / sizeof(T));
        size_t new_size = new_cap * sizeof(T);
        data = (T *) realloc(data, new_size);
        assert(data);
        cap = new_cap;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $-0x1, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
ja 0xac81
jmp 0xaca0
leaq 0x101dc(%rip), %rdi     # 0x1ae64
leaq 0x101f1(%rip), %rsi     # 0x1ae80
movl $0x21, %edx
leaq 0x101ed(%rip), %rcx     # 0x1ae88
callq 0x20d0
movq -0x30(%rbp), %rax
movq (%rax), %rax
shlq %rax
cmpq -0x10(%rbp), %rax
jbe 0xacc0
movq -0x30(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0xacc8
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x10, %rax
jbe 0xad04
movq -0x30(%rbp), %rax
movq (%rax), %rax
shlq %rax
cmpq -0x10(%rbp), %rax
jbe 0xacf2
movq -0x30(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0xacfa
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xad0f
movl $0x10, %eax
movq %rax, -0x48(%rbp)
jmp 0xad0f
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xad23
jmp 0xad42
leaq 0x101a3(%rip), %rdi     # 0x1aecd
leaq 0x1014f(%rip), %rsi     # 0x1ae80
movl $0x23, %edx
leaq 0x1014b(%rip), %rcx     # 0x1ae88
callq 0x20d0
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0xad54
jmp 0xad73
leaq 0x10185(%rip), %rdi     # 0x1aee0
leaq 0x1011e(%rip), %rsi     # 0x1ae80
movl $0x24, %edx
leaq 0x1011a(%rip), %rcx     # 0x1ae88
callq 0x20d0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x21a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
je 0xada4
jmp 0xadc3
leaq 0x10159(%rip), %rdi     # 0x1af04
leaq 0x100ce(%rip), %rsi     # 0x1ae80
movl $0x27, %edx
leaq 0x100ca(%rip), %rcx     # 0x1ae88
callq 0x20d0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: install_type_declarations(Goal*)
TypeTable install_type_declarations(Goal *goal) {
    DeclarationVisitor decl_visitor(goal->type_decls.len);
    goal->accept(&decl_visitor);

    // Free memory that was used for allocating objects
    // for parsing that doenot persist in pass 2 of type-checking.
    deallocate(MEM::PARSE_TEMP);

    return decl_visitor.type_table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
leaq -0x80(%rbp), %rdi
callq 0xd0c0
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x154e0
movl $0x1, %edi
callq 0x25d0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x78, %edx
callq 0x2100
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: params_match(Method*, Method*)
static bool params_match(Method *m1, Method *m2) {
    if (m1->param_len != m2->param_len) return false;
    size_t it = 0;
    for (Local *p1 : m1->locals) {
        if (it == m1->param_len) break;
        Local *p2 = m2->locals[it];
        if (p1->type != p2->type) return false;
        ++it;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xbf7b
movb $0x0, -0x1(%rbp)
jmp 0xc01c
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x15780
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x157a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xc018
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xbfce
jmp 0xc018
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x7870
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xbffe
movb $0x0, -0x1(%rbp)
jmp 0xc01c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0xbfa9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: check_method_for_overriding(Method*, IdType*, VirtualTable*)
bool check_method_for_overriding(Method *method, IdType *type, VirtualTable *vtable) {
    VMethod *vmethod = vtable->find(method->id);
    if (!vmethod) {
      return false;
    }
    Method *method_parent = vmethod->method;
    assert(method_parent);
    if (!methods_have_same_signature(method, method_parent)) {
        typecheck_error_no_ln(method->loc, method->ret_type->name(), " ", method->id, "(");
        print_param_types(method);
        printf(") in `%s` can't override %s %s(", type->id, method_parent->ret_type->name(),
               method_parent->id);
        print_param_types(method_parent);
        printf(") in `%s`\n", vmethod->enclosing);
        return false;
    }
    vmethod->enclosing = type->id;
    method->offset = method_parent->offset;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x15580
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc068
movb $0x0, -0x1(%rbp)
jmp 0xc16e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc07c
jmp 0xc09b
leaq 0xf6cd(%rip), %rdi      # 0x1b750
leaq 0xf6d4(%rip), %rsi      # 0x1b75e
movl $0x115, %edx            # imm = 0x115
leaq 0xf6d6(%rip), %rcx      # 0x1b76c
callq 0x20d0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf00
testb $0x1, %al
jne 0xc14a
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc180
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl -0x34(%rbp), %edi
leaq 0xe22b(%rip), %rdx      # 0x1a306
leaq 0xf7e0(%rip), %r8       # 0x1b8c2
callq 0x15600
movq -0x10(%rbp), %rdi
callq 0xc220
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc180
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
leaq 0xf693(%rip), %rdi      # 0x1b7b1
movb $0x0, %al
callq 0x2030
movq -0x30(%rbp), %rdi
callq 0xc220
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xf694(%rip), %rdi      # 0x1b7d1
movb $0x0, %al
callq 0x2030
movb $0x0, -0x1(%rbp)
jmp 0xc16e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: baziotis[P]minijava-cpp/typecheck.cpp
// Function: Type::name() const
const char *Type::name() const {
    switch (kind) {
    case TY::UNDEFINED: return "Undefined Type (Error)";
    case TY::INT: return "int";
    case TY::ARR: return "int[]";
    case TY::BOOL: return "boolean";
    case TY::ID: return ((IdType *)this)->id; 
    default: assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0xc1f7
movq -0x18(%rbp), %rax
leaq 0xf4b8(%rip), %rcx      # 0x1b664
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x107c0(%rip), %rax     # 0x1c97c
movq %rax, -0x8(%rbp)
jmp 0xc216
leaq 0xd20d(%rip), %rax      # 0x193d6
movq %rax, -0x8(%rbp)
jmp 0xc216
leaq 0xd1fa(%rip), %rax      # 0x193d0
movq %rax, -0x8(%rbp)
jmp 0xc216
leaq 0xd1f7(%rip), %rax      # 0x193da
movq %rax, -0x8(%rbp)
jmp 0xc216
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc216
leaq 0xf784(%rip), %rdi      # 0x1b982
leaq 0xf559(%rip), %rsi      # 0x1b75e
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x10782(%rip), %rcx     # 0x1c993
callq 0x20d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq