LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_ast.cpp
// Function: operator==(proc const&, proc const&)
bool operator == (proc const & a, proc const & b) {
    bool ans = a.name == b.name && a.param_t.size() == b.param_t.size();
    if (ans && a.param_t.size() > 0) {
        for (size_t i = 0; i < a.param_t.size(); ++i) {
            ans = ans && a.param_t[i] == b.param_t[i];
        }
    }
    return ans;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfb78
testb %al, %al
je 0x3bee2
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
movq 0x28(%rbx), %rdx
subq 0x20(%rbx), %rdx
cmpq %rdx, %rax
jne 0x3bee2
movb $0x1, %al
cmpq %rdi, %rcx
je 0x3bee4
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %r12
jae 0x3bee4
testb $0x1, %al
je 0x3bed7
addq %r15, %rdi
movq 0x20(%rbx), %rsi
addq %r15, %rsi
callq 0xfb78
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rcx
jmp 0x3bed9
xorl %eax, %eax
incq %r12
addq $0x20, %r15
jmp 0x3beab
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_ast.cpp
// Function: operator==(func const&, func const&)
bool operator == (func const & a, func const & b) {
    bool ans = a.name == b.name && a.rettype == b.rettype && a.param_t.size() == b.param_t.size();
    if (ans && a.param_t.size() > 0) {
        for (size_t i = 0; i < a.param_t.size(); ++i) {
            ans = ans && a.param_t[i] == b.param_t[i];
        }
    }
    return ans;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfb78
testb %al, %al
je 0x3bfd6
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0xfb78
testb %al, %al
je 0x3bfd6
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
movq 0x48(%rbx), %rdx
subq 0x40(%rbx), %rdx
cmpq %rdx, %rax
jne 0x3bfd6
movb $0x1, %al
cmpq %rdi, %rcx
je 0x3bfd8
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %r12
jae 0x3bfd8
testb $0x1, %al
je 0x3bfcb
addq %r15, %rdi
movq 0x40(%rbx), %rsi
addq %r15, %rsi
callq 0xfb78
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rcx
jmp 0x3bfcd
xorl %eax, %eax
incq %r12
addq $0x20, %r15
jmp 0x3bf9f
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_tac_gen.cpp
// Function: pl0_tac_prog(pl0_ast_prog const*)
void pl0_tac_prog(pl0_ast_prog const *prog) {
    cout << __func__;
    // set up new flag.
    valtb.tag(); vartb.tag();
    proctb.tag(); functb.tag();
    pl0_tac_const_stmt(prog->consts);
    pl0_tac_var_stmt(prog->vars);
    for (auto && e: prog->exes) {
        switch (e->t) {
            case pl0_ast_executable::type_t::PROCEDURE:
                pl0_tac_procedure_stmt(e->proc); break;
            case pl0_ast_executable::type_t::FUNCTION:
                pl0_tac_function_stmt(e->func); break;
            default: cout << "ERROR" << endl;
        }
    }
    irb.emitlabel(irb.makelabel());
    pl0_tac_compound_stmt(prog->stmts);
    // pop stack.
    valtb.detag(); vartb.detag();
    proctb.detag(), functb.detag();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x4d1c1(%rip), %r14     # 0x8afd8
leaq 0x1d721(%rip), %rsi     # 0x5b53f
movq %r14, %rdi
callq 0x5250
leaq 0x4e81b(%rip), %rdi     # 0x8c648
callq 0x46b0c
leaq 0x4e7df(%rip), %rdi     # 0x8c618
callq 0x46b2e
leaq 0x4e833(%rip), %rdi     # 0x8c678
callq 0x46b50
leaq 0x4e857(%rip), %rdi     # 0x8c6a8
callq 0x46b72
movq 0x8(%rbx), %rdi
callq 0x3df16
movq 0x10(%rbx), %rdi
callq 0x3e242
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %r13
leaq 0x1caf7(%rip), %r15     # 0x5a96e
cmpq %r13, %r12
je 0x3debb
movq (%r12), %rax
movl 0x28(%rax), %ecx
cmpl $0x1, %ecx
je 0x3de97
testl %ecx, %ecx
jne 0x3dea2
movq 0x30(%rax), %rdi
callq 0x3e841
jmp 0x3deb5
movq 0x38(%rax), %rdi
callq 0x3ed82
jmp 0x3deb5
movq %r14, %rdi
movq %r15, %rsi
callq 0x5250
movq %rax, %rdi
callq 0x5130
addq $0x8, %r12
jmp 0x3de77
leaq 0x4e70e(%rip), %r14     # 0x8c5d0
movq %r14, %rdi
callq 0x3bb88
movq %r14, %rdi
movl %eax, %esi
callq 0x46b94
movq 0x30(%rbx), %rdi
callq 0x3f645
leaq 0x4e764(%rip), %rdi     # 0x8c648
callq 0x46c92
leaq 0x4e728(%rip), %rdi     # 0x8c618
callq 0x46cd0
leaq 0x4e77c(%rip), %rdi     # 0x8c678
callq 0x46d0e
leaq 0x4e7a0(%rip), %rdi     # 0x8c6a8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x46d4c
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_tac_gen.cpp
// Function: scope_name[abi:cxx11]()
static std::string scope_name() {
    string name = "";
    for (auto && s: scope) {
        name = name + "_" + s;
    }
    return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1be71(%rip), %rsi     # 0x5b53f
leaq 0x28(%rsp), %r14
movq %r14, %rdx
callq 0xfa26
movq 0x4cf1e(%rip), %r15     # 0x8c600
movq 0x4cf1f(%rip), %rbp     # 0x8c608
leaq 0x1b300(%rip), %r12     # 0x5a9f0
leaq 0x8(%rsp), %r13
cmpq %rbp, %r15
je 0x3f737
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1def2
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xfda4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r14, %rdi
callq 0x5120
movq %r13, %rdi
callq 0x5120
addq $0x20, %r15
jmp 0x3f6f5
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3f75b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5120
movq %r14, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: pl0_env<constant>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool pl0_env<T>::find(std::string const & name, bool cross) {
    if (this->empty()) { return false; }
    for (int i = this->tb.size()-1; i >= 0; --i) {
        if (!cross && i < this->tags.back()) {
            break;
        }
        if (this->tb[i].name == name || (this->tb[i].name.rfind('_') != this->tb[i].name.npos && this->tb[i].name.substr(this->tb[i].name.rfind('_')+1) == name)) {
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x46e76
movq %rdi, %r15
subq %rcx, %rax
pushq $0x48
popq %rcx
cqto
idivq %rcx
movl %eax, %ebx
pushq $0x5f
popq %r12
pushq $-0x1
popq %r14
movq %rdi, 0x10(%rsp)
decq %rbx
testl %ebx, %ebx
js 0x46e76
cmpb $0x0, 0x4(%rsp)
jne 0x46ded
movq 0x20(%r15), %rax
cmpl %ebx, -0x4(%rax)
jg 0x46e76
movl %ebx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
imulq $0x48, %rax, %r13
movq (%r15), %rdi
addq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0xfb78
movb $0x1, %bpl
testb %al, %al
jne 0x46e78
movq (%r15), %rdi
addq %r13, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x5480
cmpq $-0x1, %rax
je 0x46dce
addq (%r15), %r13
movq %r13, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x5480
leaq 0x1(%rax), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x52a0
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0xfb78
movl %eax, %r13d
movq %r15, %rdi
movq 0x10(%rsp), %r15
callq 0x5120
testb %r13b, %r13b
je 0x46dce
jmp 0x46e78
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: pl0_env<func>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, func&)
bool pl0_env<T>::find(std::string const & name, bool cross, T & res) {
    if (this->empty()) { return false; }
    for (int i = this->tb.size()-1; i >= 0; --i) {
        if (!cross && i < this->tags.back()) {
            break;
        }
        if (this->tb[i].name == name || (this->tb[i].name.rfind('_') != this->tb[i].name.npos && this->tb[i].name.substr(this->tb[i].name.rfind('_')+1) == name)) {
            res = this->tb[i];
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x4(%rsp)
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
cmpq %rax, %rdx
je 0x47670
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, 0x10(%rsp)
subq %rdx, %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movl %eax, %ebp
movq %rdi, 0x8(%rsp)
pushq $-0x1
popq %r15
decq %rbp
testl %ebp, %ebp
js 0x47670
cmpb $0x0, 0x4(%rsp)
jne 0x475d6
movq 0x20(%rbx), %rax
cmpl %ebp, -0x4(%rax)
jg 0x47670
movl %ebp, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
imulq $0x58, %rax, %r12
movq (%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0xfb78
testb %al, %al
jne 0x4765c
movq (%rbx), %rdi
addq %r12, %rdi
pushq $0x5f
popq %rsi
pushq $-0x1
popq %rdx
callq 0x5480
cmpq $-0x1, %rax
je 0x475b7
movq 0x8(%rsp), %rax
movq (%rax), %rbx
addq %r12, %rbx
movq %rbx, %rdi
pushq $0x5f
popq %rsi
movq %r15, %rdx
callq 0x5480
leaq 0x1(%rax), %rdx
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x52a0
movq %r13, %rdi
movq %r14, %rsi
callq 0xfb78
movl %eax, %ebx
movq %r13, %rdi
callq 0x5120
testb %bl, %bl
movq 0x8(%rsp), %rbx
je 0x475b7
addq (%rbx), %r12
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x49106
movb $0x1, %al
jmp 0x47672
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: Value::value[abi:cxx11]() const
std::string value() const {
        if (this->t == TYPE::IMM) {
            return to_string(this->iv);
        }
        else {
            return this->sv;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x47ccb
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x5340
jmp 0x47cd6
movl 0x4(%rsi), %esi
movq %rbx, %rdi
callq 0x3cc01
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: BasicBlock::dump()
void BasicBlock::dump() {
    cout << ";; +++++++++++++++++++ Basic block: ";
    if (this->no == 0) {
        cout << "header ";
        cout << "begin with: " << this->begin << " ";
        cout << "end with: " << this->end << " ";
    }
    else {
        cout << this->no << " ";
        cout << "prefix: [";
        for (auto && i: this->prefix) { cout << i << " "; }
        cout << "]  ";
        cout << "suffix: [";
        for (auto && i: this->suffix) { cout << i << " "; }
        cout << "]";
    }
    if (this->is_end) { cout << " is end "; }
    cout << endl;
    for (auto && c: this->code) {
        cout << ";; " << c.str() << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x4143e(%rip), %rdi     # 0x8afd8
leaq 0x1110f(%rip), %rsi     # 0x5acb0
callq 0x5250
movl (%rbx), %esi
movq 0x41429(%rip), %r14     # 0x8afd8
testl %esi, %esi
je 0x49c70
movq %r14, %rdi
callq 0x53e0
leaq 0x11770(%rip), %r15     # 0x5b336
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
leaq 0x1111d(%rip), %rsi     # 0x5acf5
movq %r14, %rdi
callq 0x5250
movq 0x30(%rbx), %r12
movq 0x38(%rbx), %r13
cmpq %r13, %r12
je 0x49c0a
movl (%r12), %esi
movq %r14, %rdi
callq 0x53e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
addq $0x4, %r12
jmp 0x49be8
movq 0x413c7(%rip), %r14     # 0x8afd8
leaq 0x110e7(%rip), %rsi     # 0x5acff
movq %r14, %rdi
callq 0x5250
leaq 0x110dc(%rip), %rsi     # 0x5ad03
movq %r14, %rdi
callq 0x5250
movq 0x48(%rbx), %r12
movq 0x50(%rbx), %r13
leaq 0x116f8(%rip), %r15     # 0x5b336
cmpq %r13, %r12
je 0x49c60
movl (%r12), %esi
movq %r14, %rdi
callq 0x53e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
addq $0x4, %r12
jmp 0x49c3e
movq 0x41371(%rip), %rdi     # 0x8afd8
leaq 0x10fda(%rip), %rsi     # 0x5ac48
jmp 0x49ccb
leaq 0x1105e(%rip), %rsi     # 0x5acd5
movq %r14, %rdi
callq 0x5250
leaq 0x11057(%rip), %rsi     # 0x5acdd
movq %r14, %rdi
callq 0x5250
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x53e0
leaq 0x11696(%rip), %r15     # 0x5b336
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
leaq 0x11038(%rip), %rsi     # 0x5acea
movq %r14, %rdi
callq 0x5250
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x53e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
cmpb $0x1, 0x5(%rbx)
jne 0x49ce9
movq 0x412fb(%rip), %rdi     # 0x8afd8
leaq 0x11029(%rip), %rsi     # 0x5ad0d
callq 0x5250
movq 0x412e8(%rip), %r14     # 0x8afd8
movq %r14, %rdi
callq 0x5130
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %rbp
leaq 0x1138e(%rip), %rbx     # 0x5b095
leaq 0x8(%rsp), %r12
cmpq %rbp, %r15
je 0x49d4b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5250
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3b76c
movq %r13, %rdi
movq %r12, %rsi
callq 0x5210
movq %rax, %rdi
callq 0x5130
movq %r12, %rdi
callq 0x5120
addq $0x50, %r15
jmp 0x49d0c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: BasicBlock::findNode(Value*)
int BasicBlock::findNode(Value *val) {
    int k = record.count(*val);
    if (k == 0) {
        k = G.size();
        G.emplace_back(DAGNode(k, val));
        return k;
    }
    else {
        return record[*val];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x78(%rdi), %r15
movq %r15, %rdi
callq 0x4b8e8
testl %eax, %eax
je 0x4a4fb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4b95e
movl (%rax), %r14d
jmp 0x4a536
leaq 0x60(%r14), %r15
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
movq %rsp, %r12
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x4b902
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b832
movq %rsp, %rdi
callq 0x4b8ce
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b8ce
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: BasicBlock::setMap(Value*, int)
void BasicBlock::setMap(Value *val, int node) {
    auto iter = record.find(*val);
    if (iter == record.end()) {
        record[*val] = node;
        G[node].addItem(val);
    }
    else if (iter->second == node) {
        return;
    }
    else {
        auto it = G[iter->second].items.begin();
        while (it != G[iter->second].items.end()) {
            if (*(*it) == *val) {
                it = G[iter->second].items.erase(it);
            }
            else {
                it++;
            }
        }
        record[*val] = node;
        G[node].addItem(val);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x78(%rdi), %r15
movq %r15, %rdi
callq 0x4d2ee
movq %rax, %r12
leaq 0x80(%r14), %rax
cmpq %rax, %r12
je 0x4a59e
movl 0x68(%r12), %eax
cmpl %ebp, %eax
jne 0x4a5b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4b95e
movl %ebp, (%rax)
addq $0x60, %r14
jmp 0x4a61e
movslq %eax, %rdx
movq 0x60(%r14), %rcx
addq $0x60, %r14
imulq $0x58, %rdx, %rdx
movq 0x18(%rcx,%rdx), %r13
cltq
imulq $0x58, %rax, %rax
cmpq 0x20(%rcx,%rax), %r13
je 0x4a611
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x4b9da
testb %al, %al
je 0x4a603
movslq 0x68(%r12), %rax
movq (%r14), %rcx
imulq $0x58, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x18, %rdi
movq %r13, %rsi
callq 0x4b9fe
movq %rax, %r13
jmp 0x4a607
addq $0x8, %r13
movl 0x68(%r12), %eax
movq (%r14), %rcx
jmp 0x4a5c5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4b95e
movl %ebp, (%rax)
movslq %ebp, %rax
imulq $0x58, %rax, %rdi
addq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b9c4
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: BasicBlock::findNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*, int, int)
int BasicBlock::findNode(std::string op, Value *val, int rs, int rt) {
    // find op and target.
    auto iter = std::find_if(G.begin(), G.end(), [&](DAGNode & node) {
        return op == node.op && rs == node.lhs && rt == node.rhs;
    });
    if (iter != G.end()) {
        return iter - G.begin();
    }
    else {
        int k = G.size();
        G.emplace_back(DAGNode(k, op, val, rs, rt));
        G[rs].moreFa(); G[rt].moreFa();
        return k;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, %r12
leaq 0xc(%rsp), %rax
movl %ecx, (%rax)
leaq 0x8(%rsp), %rcx
movl %r8d, (%rcx)
leaq 0x60(%rdi), %rdx
movq %rdx, 0x18(%rsp)
movq 0x60(%rdi), %r15
movq 0x68(%rdi), %r14
leaq 0x50(%rsp), %rbp
movq %rsi, 0x20(%rsp)
movq %rsi, (%rbp)
movq %rax, 0x8(%rbp)
movq %rcx, 0x10(%rbp)
movq %r14, 0x10(%rsp)
subq %r15, %r14
pushq $0x58
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %rbx
sarq $0x2, %rbx
testq %rbx, %rbx
jle 0x4a719
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4b6b2
testb %al, %al
jne 0x4a76d
leaq 0x58(%r15), %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4b6b2
testb %al, %al
jne 0x4a770
leaq 0xb0(%r15), %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4b6b2
testb %al, %al
jne 0x4a770
leaq 0x108(%r15), %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4b6b2
testb %al, %al
jne 0x4a770
addq $0x160, %r15            # imm = 0x160
decq %rbx
addq $-0x160, %r14           # imm = 0xFEA0
jmp 0x4a6a7
movq %r14, %rax
cqto
pushq $0x58
popq %rbx
idivq %rbx
cmpq $0x1, %rax
je 0x4a81f
cmpq $0x2, %rax
je 0x4a753
cmpq $0x3, %rax
jne 0x4a811
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x4b6b2
testb %al, %al
jne 0x4a768
addq $0x58, %r15
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x4b6b2
testb %al, %al
je 0x4a81b
movq %r15, %r13
jmp 0x4a773
movq %r15, %r13
pushq $0x58
popq %rbx
movq %r13, %rax
subq 0x60(%r12), %rax
cqto
idivq %rbx
movq %rax, %rbx
cmpq 0x68(%r12), %r13
jne 0x4a7fd
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq 0x20(%rsp), %rsi
callq 0x5340
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
leaq 0x50(%rsp), %rdi
movl %ebx, %esi
movq %r14, %rdx
movq 0x28(%rsp), %rcx
callq 0x4b86e
leaq 0x50(%rsp), %rsi
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x4b832
leaq 0x50(%rsp), %rdi
callq 0x4b8ce
leaq 0x30(%rsp), %rdi
callq 0x5120
movslq 0xc(%rsp), %rax
movq (%r14), %rcx
imulq $0x58, %rax, %rax
incl 0x4(%rcx,%rax)
movslq 0x8(%rsp), %rax
imulq $0x58, %rax, %rax
incl 0x4(%rcx,%rax)
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %r13
jmp 0x4a773
addq $0x58, %r15
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x4b6b2
testb %al, %al
movq 0x10(%rsp), %r13
cmovneq %r15, %r13
jmp 0x4a773
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4b8ce
jmp 0x4a84e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: BasicBlock::releaseLeaf(std::vector<TAC, std::allocator<TAC>>&, Value*)
void BasicBlock::releaseLeaf(std::vector<TAC> & irs, Value *item) {
    auto iter = G.begin();
    while (iter != G.end()) {
        DAGNode & node = *iter; // reference.
        if (node.leaf && record[*item] != node.no) {
            if (node.item == item && !node.items.empty()) {
                auto i_iter = node.items.begin();
                node.item = *i_iter;
                node.items.erase(i_iter);
                releaseLeaf(irs, node.item);
                if (node.item->str() != item->str()) {
                    irs.push_back(TAC("=", node.item, item));
                }
            }
        }
        iter++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
movq 0x60(%rdi), %r12
leaq 0x78(%rdi), %r13
addq $0x18, %r12
leaq 0x48(%rsp), %rbp
leaq -0x18(%r12), %r14
cmpq 0x68(%r15), %r14
je 0x4acf4
cmpb $0x1, -0xf(%r12)
jne 0x4ac32
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4b95e
movl (%rax), %eax
cmpl (%r14), %eax
je 0x4ac32
cmpq %rbx, -0x8(%r12)
je 0x4ac38
addq $0x58, %r12
jmp 0x4ac02
movq (%r12), %rsi
cmpq 0x8(%r12), %rsi
je 0x4ac32
movq (%rsi), %rax
movq %rax, -0x8(%r12)
movq %r12, %rdi
callq 0x4b9fe
movq -0x8(%r12), %rdx
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x4abd6
movq -0x8(%r12), %rsi
movq %rbp, %rdi
callq 0x3b720
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b720
movq %rbp, %rdi
movq %r14, %rsi
callq 0xfd9a
movq %r14, %rdi
movl %eax, %r14d
callq 0x5120
movq %rbp, %rdi
callq 0x5120
testb %r14b, %r14b
je 0x4ac32
leaq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0xe465(%rip), %rsi      # 0x59118
leaq 0x28(%rsp), %rdx
callq 0xfa26
movq -0x8(%r12), %rdx
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x47f44
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x47f08
movq %rbp, %rdi
callq 0x3ccde
movq %r14, %rdi
callq 0x5120
jmp 0x4ac32
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3ccde
jmp 0x4ad18
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x4ad2c
movq %rax, %rbx
jmp 0x4ad31
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_opt.cpp
// Function: pl0_block(std::vector<TAC, std::allocator<TAC>>&, std::vector<BasicBlock, std::allocator<BasicBlock>>&, int)
int pl0_block(std::vector<TAC> & code, std::vector<BasicBlock> & bbs, int p) {
    std::map<int, std::vector<int>> pres, sufs;
    pl0_block_helper(code, bbs, p, pres, sufs);
    for (auto && bb: bbs) {
        bb.setPrefix(pres[bb.no]);
        bb.setSuffix(sufs[bb.no]);
    }
    return bbs.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
leaq 0x38(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x8(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x30(%rsp), %rcx
movq %rsp, %r8
callq 0x4b15e
movq (%rbx), %r14
movq 0x8(%rbx), %r13
leaq 0x30(%rsp), %r15
movq %rsp, %r12
cmpq %r13, %r14
je 0x4b109
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bade
addq $0x30, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b72c
addq $-0x30, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4bade
addq $0x48, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b72c
addq $0x78, %r14
jmp 0x4b0c6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movl $0xc0, %ecx
cqto
idivq %rcx
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4c90c
leaq 0x30(%rsp), %rdi
callq 0x4c90c
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4b141
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4c90c
leaq 0x30(%rsp), %rdi
callq 0x4c90c
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: Value::operator==(Value const&) const
bool operator == (Value const & v) const {
        bool res = t == v.t;
        if (res) {
            if (t == TYPE::IMM) {
                res = res && iv == v.iv;
            }
            else {
                res = res && sv == v.sv;
            }
        }
        return res;
    }

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x4b9f1
testl %eax, %eax
je 0x4b9f4
addq $0x8, %rdi
addq $0x8, %rsi
jmp 0xfb78
xorl %eax, %eax
retq
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_allocator.cpp
// Function: SimpleAllocator::release(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void SimpleAllocator::release(std::string name, bool is_reg) {
    if (is_reg) {
        // release register.
        if (this->used[name]) {
            this->used[name] = false;
            this->record.erase(name);
        }
    }
    else {
        // release variable.
        for (auto && p: this->record) {
            if (p.second == name) {
                this->used[p.first] = false;
                this->record.erase(p.first);
                break;
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x4de7b
leaq 0xc0(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f0cc
cmpb $0x1, (%rax)
jne 0x4deb3
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f0cc
movb $0x0, (%rax)
addq $0xf0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x4dedc
leaq 0xf0(%rbx), %r15
movq 0x108(%rbx), %r12
leaq 0xf8(%rbx), %r13
cmpq %r13, %r12
je 0x4deb3
leaq 0x40(%r12), %rdi
movq %r14, %rsi
callq 0xfb78
testb %al, %al
jne 0x4debd
movq %r12, %rdi
callq 0x51a0
movq %rax, %r12
jmp 0x4de90
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x20, %r12
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f0cc
movb $0x0, (%rax)
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4ff34
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_allocator.cpp
// Function: SimpleAllocator::spill(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SimpleAllocator::spill(std::string reg) {
    if (this->used[reg]) {
        this->store(this->record[reg]);
        this->release(reg, true);
    }
    else {
        // DO NOTHING
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0xc0, %rdi
callq 0x4f0cc
cmpb $0x1, (%rax)
jne 0x4e67a
leaq 0xf0(%rbx), %rdi
movq %r15, %rsi
callq 0x4f132
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5340
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
leaq 0x20(%rsp), %rdi
callq 0x5120
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5340
movq (%rbx), %rax
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rsp, %rdi
callq 0x5120
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4e686
movq %rax, %rbx
movq %r14, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_allocator.cpp
// Function: SimpleAllocator::locate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SimpleAllocator::locate(std::string name) {
    std::string res;
    if ((res = exist(name)).length() == 0) {
        LOC loc;
        env.find(name, true, loc);
        res = "dword " + this->addr(name);
    }
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x5340
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x4f010
leaq 0x68(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x52f0
movq 0x8(%rax), %r13
movq %r12, %rdi
callq 0x5120
leaq 0x48(%rsp), %rdi
callq 0x5120
testq %r13, %r13
jne 0x4ec25
leaq 0x68(%rsp), %rdi
callq 0x4f086
movq 0x8(%r14), %rdi
pushq $0x1
popq %rdx
leaq 0x68(%rsp), %rcx
movq %r15, %rsi
callq 0x4f2e2
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x5340
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq *0x48(%rax)
leaq 0xc199(%rip), %rsi      # 0x5ad73
leaq 0xb0(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xfac0
leaq 0xb0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r14, %rdi
callq 0x5120
leaq 0x28(%rsp), %rdi
callq 0x5120
leaq 0x8(%rsp), %rdi
callq 0x5120
leaq 0x68(%rsp), %rdi
callq 0x4f1b6
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5120
jmp 0x4ec4b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5120
jmp 0x4ec5c
jmp 0x4ec59
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x4f1b6
jmp 0x4ec7c
jmp 0x4ec79
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5120
jmp 0x4ec7c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5120
movq %r14, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_x86.h
// Function: RegisterAllocator::exist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string exist(std::string name) {
        for (auto && x: record) {
            if (x.second == name) {
                return x.first;
            }
        }
        return "";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x108(%rsi), %r12
addq $0xf8, %r15
cmpq %r15, %r12
je 0x4f052
leaq 0x40(%r12), %rdi
movq %r14, %rsi
callq 0xfb78
testb %al, %al
jne 0x4f068
movq %r12, %rdi
callq 0x51a0
movq %rax, %r12
jmp 0x4f02f
leaq 0xc4e6(%rip), %rsi      # 0x5b53f
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xfa26
jmp 0x4f077
addq $0x20, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_x86.cpp
// Function: pl0_x86_gen_blocks(std::vector<BasicBlock, std::allocator<BasicBlock>>&, unsigned long)
static size_t pl0_x86_gen_blocks(std::vector<BasicBlock> & bbs, size_t bp = 0) {
    std::vector<std::string> buffer;
    pl0_x86_gen_header(bbs[bp++], buffer);
    runtime.dump();
    while (bp < bbs.size() && bbs[bp].no == 0) {
        bp = pl0_x86_gen_blocks(bbs, bp);
    }
    for (auto && s: buffer) {
        out.emit(s);
    }
    while (bp < bbs.size() && bbs[bp].no != 0) {
        pl0_x86_gen_body(bbs[bp]);
        if (bbs[bp++].is_end) {
            break; // the end block of a procedure or a function.
        }
    }
    return bp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
andq $0x0, 0x10(%rsi)
movaps %xmm0, (%rsi)
imulq $0xc0, %rbx, %rdi
addq (%r14), %rdi
callq 0x50d45
leaq 0x3baee(%rip), %rdi     # 0x8c720
callq 0x56d3c
incq %rbx
movl $0xc0, %r15d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %r15
cmpq %rax, %rbx
jae 0x50c71
imulq $0xc0, %rbx, %rax
cmpl $0x0, (%rcx,%rax)
jne 0x50c71
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50bfa
movq %rax, %rbx
jmp 0x50c40
movq (%rsp), %r15
movq 0x8(%rsp), %rbp
leaq 0x18(%rsp), %r12
leaq 0x3ba62(%rip), %r13     # 0x8c6e8
cmpq %rbp, %r15
je 0x50caf
movq %r12, %rdi
movq %r15, %rsi
callq 0x5340
movq %r13, %rdi
movq %r12, %rsi
callq 0x4f2cc
movq %r12, %rdi
callq 0x5120
addq $0x20, %r15
jmp 0x50c86
movq (%r14), %rcx
movl $0xc0, %r12d
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %rbx
jae 0x50d03
imulq $0xc0, %rbx, %r13
cmpl $0x0, (%rcx,%r13)
je 0x50d03
addq %r13, %rcx
movq 0x18(%rcx), %r15
movq 0x20(%rcx), %rbp
cmpq %rbp, %r15
je 0x50cf5
movq %r15, %rdi
callq 0x5156b
addq $0x50, %r15
jmp 0x50ce2
incq %rbx
movq (%r14), %rcx
cmpb $0x1, 0x5(%rcx,%r13)
jne 0x50cb8
movq %rsp, %rdi
callq 0x46752
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50d32
jmp 0x50d32
jmp 0x50d32
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5120
jmp 0x50d35
movq %rax, %rbx
movq %rsp, %rdi
callq 0x46752
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: pl0_env<LOC>::dump()
void dump() {
        cout << ";; -----------------  Symbol Table  -------------------" << endl;
        for (auto && t: tb) {
            cout << ";; " << t.str() << endl;
        }
        cout << ";; -----------------------------------------------------" << endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq 0x34284(%rip), %rbx     # 0x8afd8
leaq 0x433e(%rip), %rsi      # 0x5b099
movq %rbx, %rdi
callq 0x5250
movq %rax, %rdi
callq 0x5130
movq (%r15), %r14
movq 0x8(%r15), %rbp
leaq 0x431c(%rip), %r15      # 0x5b095
leaq 0x8(%rsp), %r12
cmpq %rbp, %r14
je 0x56dbd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5250
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x570d2
movq %r13, %rdi
movq %r12, %rsi
callq 0x5210
movq %rax, %rdi
callq 0x5130
movq %r12, %rdi
callq 0x5120
addq $0x48, %r14
jmp 0x56d7e
movq 0x34214(%rip), %rdi     # 0x8afd8
leaq 0x4306(%rip), %rsi      # 0x5b0d1
callq 0x5250
movq %rax, %rdi
callq 0x5130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sharmin-lalani[P]Port-knocking-Backdoor/knocker.c
// Function: main
int main(int argv, char** argc) {

	FILE *config_file; 
	int sockfd, n, serverlen;
	short unsigned int port_num;
	struct sockaddr_in serveraddr, srcaddr;

	// parse the config file   	
	config_file = fopen(argc[1],"r");
    	if(config_file == NULL) {
        	printf("Unable to open config file.\n");
		return -1;
    	}

	
    	/* socket: create the socket */
    	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    	if (sockfd < 0) {
        	printf("ERROR opening socket\n");
		return -1;
	}

    	/* build the server's Internet address */
    	memset(&serveraddr, 0, sizeof(serveraddr));
    	serveraddr.sin_family = AF_INET;
	inet_aton(argc[2], &serveraddr.sin_addr);

	/* build the knocker's Internet address */
	memset(&srcaddr, 0, sizeof(srcaddr));
	srcaddr.sin_family = AF_INET;
	srcaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    	srcaddr.sin_port = htons(22222);

	/* bind the client socket */
	if (bind(sockfd, (struct sockaddr *) &srcaddr, sizeof(srcaddr)) < 0)
		printf("ERROR in bind\n");

	serverlen = sizeof(serveraddr);

	while (fscanf(config_file, "%hu", &port_num) == 1) {
		//printf("%d\n", port_num);		

		serveraddr.sin_port = htons(port_num);
    		/* send the message to the server */
    		n = sendto(sockfd, NULL, 0, 0, (const sockaddr*)&serveraddr, serverlen);
    		if (n < 0) 
      			printf("ERROR in sendto\n");
		//else
			//printf("packet successfully sent\n");
		sleep(0.1);    

	}
	fclose(config_file);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq 0x8(%rsi), %rdi
leaq 0xe29(%rip), %rsi       # 0x2004
callq 0x1090
testq %rax, %rax
je 0x12b3
movq %rax, %rbx
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x1050
testl %eax, %eax
js 0x12bc
movl %eax, %r14d
xorps %xmm0, %xmm0
leaq -0x3c(%rbp), %rsi
movaps %xmm0, -0x4(%rsi)
movw $0x2, -0x4(%rsi)
movq 0x10(%r15), %rdi
callq 0x1060
leaq -0x50(%rbp), %rsi
andq $0x0, 0x8(%rsi)
movl $0xce560002, %eax       # imm = 0xCE560002
movq %rax, (%rsi)
pushq $0x10
popq %rdx
movl %r14d, %edi
callq 0x1040
testl %eax, %eax
jns 0x1249
leaq 0xdc6(%rip), %rdi       # 0x200a
callq 0x10a0
leaq -0x2a(%rbp), %r12
leaq -0x40(%rbp), %r13
pushq $0x10
popq %r15
movq %rbx, %rdi
leaq 0xda7(%rip), %rsi       # 0x2006
movq %r12, %rdx
xorl %eax, %eax
callq 0x10b0
cmpl $0x1, %eax
jne 0x12a7
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x3e(%rbp)
movl %r14d, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r8
movl %r15d, %r9d
callq 0x1030
testl %eax, %eax
jns 0x129e
leaq 0xd7f(%rip), %rdi       # 0x2018
callq 0x10a0
xorl %edi, %edi
callq 0x1070
jmp 0x1255
movq %rbx, %rdi
callq 0x1080
xorl %eax, %eax
jmp 0x12cb
leaq 0xd83(%rip), %rdi       # 0x203d
jmp 0x12c3
leaq 0xd65(%rip), %rdi       # 0x2028
callq 0x10a0
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/main.cpp
// Function: Update()
void Update() {
    #ifndef NDEBUG
    if(IsKeyPressed(KEY_R))
        RenderManager::ReloadShaders();
    #endif

    Game::Update();
    RenderManager::Render();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq $0x52
popq %rdi
callq 0x2f2aa
testb %al, %al
je 0x966c
callq 0xed4c
callq 0xb116
popq %rbp
jmp 0xef61
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/utils.cpp
// Function: Lerp(Color, Color, float)
Color Lerp(Color v0, Color v1, float t) {
    if(t<=0) return v0;
    if(t>1) return v1;
    return (Color){(unsigned char)((1 - t) * v0.r + t * v1.r),
                   (unsigned char)((1 - t) * v0.g + t * v1.g),
                   (unsigned char)((1 - t) * v0.b + t * v1.b),
                   (unsigned char)((1 - t) * v0.a + t * v1.a)};
}

// Assembly:
movl %edi, %eax
shrl $0x8, %eax
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %edx
shrl $0x18, %edx
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x9d74
pushq %rbp
movq %rsp, %rbp
movl %esi, %r10d
shrl $0x8, %r10d
movl %esi, %r9d
shrl $0x10, %r9d
movl %esi, %r8d
shrl $0x18, %r8d
ucomiss 0x8e45a(%rip), %xmm0    # 0x98134
jbe 0x9cec
movl %esi, %edi
movl %r10d, %eax
movl %r9d, %ecx
movl %r8d, %edx
jmp 0x9d73
movss 0x8e440(%rip), %xmm1    # 0x98134
movl $0xff, %r11d
andl %r11d, %edi
cvtsi2ss %edi, %xmm2
andl %r11d, %esi
cvtsi2ss %esi, %xmm3
subss %xmm0, %xmm1
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
andl %r11d, %eax
cvtsi2ss %eax, %xmm3
andl %r11d, %r10d
cvtsi2ss %r10d, %xmm4
cvttss2si %xmm2, %edi
mulss %xmm0, %xmm4
mulss %xmm1, %xmm3
addss %xmm4, %xmm3
cvttss2si %xmm3, %eax
andl %r11d, %ecx
cvtsi2ss %ecx, %xmm2
andl %r11d, %r9d
cvtsi2ss %r9d, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %ecx
cvtsi2ss %edx, %xmm2
cvtsi2ss %r8d, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %edx
popq %rbp
movzbl %dl, %edx
shll $0x18, %edx
movzbl %cl, %ecx
shll $0x10, %ecx
orl %edx, %ecx
movzbl %al, %edx
shll $0x8, %edx
orl %ecx, %edx
movzbl %dil, %eax
orl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemy.cpp
// Function: Enemy::Enemy(int, int, Color)
Enemy::Enemy(int x, int y, Color color) : _model("assets/models/ghost.obj",color){
	_spawnX = x;
	_spawnY = y;
	_x = x;
	_y = y;
	_model.position = {(float)x, 0, (float)y};
	_direcaoY = 0;
	_direcaoX = 0;
	
	_scatter = false;
	_alive = true;

	_color = color;
	_velocidade = GHOST_SPEED_DEFAULT;

	_timerMovimento = 0.0;
	_timerScatter = 0.0;
	
	_goalX = 1.0;
	_goalY = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0xb1ce
leaq 0xcbba9(%rip), %rax     # 0xd5a40
movq %rax, (%rbx)
leaq 0x8e397(%rip), %rsi     # 0x98238
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x8310
leaq 0x8(%rbx), %rdi
leaq -0x48(%rbp), %rsi
movl %r14d, %edx
callq 0xdbf6
leaq -0x48(%rbp), %rdi
callq 0x83a0
movl %r12d, 0x2c0(%rbx)
movl %r15d, 0x2c4(%rbx)
movl %r12d, 0x2c8(%rbx)
movl %r15d, 0x2cc(%rbx)
cvtsi2ss %r12d, %xmm0
cvtsi2ss %r15d, %xmm1
movss %xmm0, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
movss %xmm1, 0x20(%rbx)
andq $0x0, 0x2d0(%rbx)
movw $0x100, 0x2d8(%rbx)     # imm = 0x100
movl %r14d, 0x2e0(%rbx)
movl $0x40400000, 0x2dc(%rbx) # imm = 0x40400000
movaps 0x8e2ec(%rip), %xmm0    # 0x98210
movups %xmm0, 0x2e4(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x83a0
jmp 0x9f49
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1fa
movq %r14, %rdi
callq 0x8ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemy.cpp
// Function: Enemy::OnRestart()
void Enemy::OnRestart(){
	_model.position = {(float)_spawnX, 0, (float)_spawnY};
	_model.SetColor(_color);
	_direcaoX = 0;
	_direcaoY = 0;
	_x = _spawnX;
	_y = _spawnY;
	_scatter = false;
	_scared = false;
	_alive = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2ssl 0x2c0(%rdi), %xmm0
cvtsi2ssl 0x2c4(%rdi), %xmm1
movss %xmm0, 0x18(%rdi)
andl $0x0, 0x1c(%rdi)
addq $0x8, %rdi
movss %xmm1, 0x20(%rbx)
movl 0x2e0(%rbx), %esi
callq 0xde22
andq $0x0, 0x2d0(%rbx)
movq 0x2c0(%rbx), %rax
movq %rax, 0x2c8(%rbx)
xorl %eax, %eax
movb %al, 0x2d8(%rbx)
movb %al, 0xcea19(%rip)      # 0xd8e49
movb $0x1, 0x2d9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::MenuStateUpdate()
void MenuStateUpdate(){
        GameEvents::TriggerMenuUpdate();
        UI::DrawImage("assets/interface/title.png",0.5,0.4,0.75,0.75);
        UI::DrawTextCentered("Press space", 0.5, 0.8, 7, 0.0, { 246, 196, 2, 255 });

        #if defined(NDEBUG) && !defined(EMSCRIPTEN)
        if(1.0-introFadeTimer > 0){
            UI::DrawRect(0,0,1,1,Lerp(RAYWHITE, {0, 0, 0, 0}, introFadeTimer));
            introFadeTimer+=2*Clamp(GetFrameTime(),0,0.016);
        }
        #endif

        if(IsKeyDown(KEY_SPACE)){
            pacman->Resetar();
            GameEvents::TriggerRestart();
            SetState(Game::GameStart);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
callq 0xb144
leaq 0x8d987(%rip), %rsi     # 0x98375
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x8310
leaq -0x50(%rbp), %rdi
movss 0x8d8bd(%rip), %xmm0    # 0x982c4
movss 0x8d8b9(%rip), %xmm1    # 0x982c8
movss 0x8d8b5(%rip), %xmm2    # 0x982cc
movaps %xmm2, %xmm3
callq 0xf91a
leaq -0x50(%rbp), %rdi
callq 0x83a0
leaq 0x8d961(%rip), %rsi     # 0x98390
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x8310
leaq -0x30(%rbp), %rdi
movss 0x8d87c(%rip), %xmm0    # 0x982c4
movss 0x8d880(%rip), %xmm1    # 0x982d0
movss 0x8d87c(%rip), %xmm2    # 0x982d4
xorps %xmm3, %xmm3
movl $0xff02c4f6, %esi       # imm = 0xFF02C4F6
callq 0xfa52
leaq -0x30(%rbp), %rdi
callq 0x83a0
pushq $0x20
popq %rdi
callq 0x2f308
testb %al, %al
je 0xaa93
movq 0xce3d7(%rip), %rdi     # 0xd8e58
callq 0xd1c4
callq 0xb1a0
pushq $0x2
popq %rdi
callq 0xa8db
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0xaaac
jmp 0xaab3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x83a0
jmp 0xaab6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::GameStartStateUpdate()
void GameStartStateUpdate(){
        if(stateTimer < 2){
            UI::DrawTextCentered("START!", 0.5, 0.4, 7, 0.0, WHITE);
            GameEvents::TriggerMenuUpdate();

            Vector2 pacSpawn = Mapa::GetPlayerSpawn();
            RenderManager::CameraFollow({pacSpawn.x, 0, pacSpawn.y}, 3);
        }else{
            SetState(GameInProgress);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movsd 0x8d7f5(%rip), %xmm0    # 0x98310
ucomisd 0xce33d(%rip), %xmm0    # 0xd8e60
jbe 0xab91
leaq 0x8d896(%rip), %rsi     # 0x983c2
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x8310
movss 0x8d780(%rip), %xmm0    # 0x982c4
movss 0x8d77c(%rip), %xmm1    # 0x982c8
movss 0x8d780(%rip), %xmm2    # 0x982d4
pushq $-0x1
popq %rsi
xorps %xmm3, %xmm3
movq %rbx, %rdi
callq 0xfa52
leaq -0x30(%rbp), %rdi
callq 0x83a0
callq 0xb144
callq 0xc036
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm2, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movss 0x8d67a(%rip), %xmm2    # 0x98204
callq 0xee67
jmp 0xabb8
andq $0x0, 0xce2c7(%rip)     # 0xd8e60
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0xce2d6(%rip)     # 0xd8e80
leaq 0x39(%rip), %rax        # 0xabea
movq %rax, 0xce2c0(%rip)     # 0xd8e78
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::LevelClearedStateUpdate()
void LevelClearedStateUpdate(){
        if(stateTimer < 4){
            std::ostringstream scoreString;
            scoreString << "Score:" << pacman->GetPontuacao();
            UI::DrawTextCentered(scoreString.str(), 0.5, 0.05, 5, 0.5, RAYWHITE);
            UI::DrawTextCentered("Level Cleared!", 0.5, 0.5, 15, 0.0, WHITE);
            GameEvents::TriggerMenuUpdate();
        }else{
            Mapa::Recarrega();
            GameEvents::TriggerRestart();
            SetState(GameStart);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movsd 0x8d53f(%rip), %xmm0    # 0x98328
ucomisd 0xce06f(%rip), %xmm0    # 0xd8e60
jbe 0xaecd
leaq -0x1c8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8aa0
leaq 0x8d5bc(%rip), %rsi     # 0x983c9
movq %rbx, %rdi
callq 0x8840
movq %rax, %rbx
movq 0xce039(%rip), %rdi     # 0xd8e58
callq 0xd548
movl %eax, %esi
movq %rbx, %rdi
callq 0x8570
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8d40
leaq -0x50(%rbp), %rdi
movss 0x8d48e(%rip), %xmm1    # 0x982d8
movss 0x8d3e2(%rip), %xmm2    # 0x98234
movss 0x8d46a(%rip), %xmm0    # 0x982c4
movapd %xmm0, %xmm3
movl $0xfff5f5f5, %esi       # imm = 0xFFF5F5F5
callq 0xfa52
leaq -0x50(%rbp), %rdi
callq 0x83a0
leaq 0x8d579(%rip), %rsi     # 0x983f1
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x8310
leaq -0x30(%rbp), %rdi
movss 0x8d433(%rip), %xmm0    # 0x982c4
movss 0x8d44b(%rip), %xmm2    # 0x982e4
pushq $-0x1
popq %rsi
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm1
callq 0xfa52
leaq -0x30(%rbp), %rdi
callq 0x83a0
callq 0xb144
leaq -0x1c8(%rbp), %rdi
callq 0x81a0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
callq 0xbce4
callq 0xb1a0
pushq $0x2
popq %rdi
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
jmp 0xa8db
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0xaefa
jmp 0xaf01
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x83a0
jmp 0xaf04
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x8ed0
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/gameEvents.cpp
// Function: GameEvents::~GameEvents()
GameEvents::~GameEvents(){
    for(unsigned i=0; i<_events.size(); i++){
        //Remove "this" from the vector, doesn't maintain order
        if(_events[i] == this){
            _events[i] = _events[_events.size()-1];
            _events.pop_back();
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xca893(%rip), %rax     # 0xd5a98
movq %rax, (%rdi)
movq 0xcdc89(%rip), %rcx     # 0xd8e98
movq 0xcdc7a(%rip), %rax     # 0xd8e90
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
xorl %r8d, %r8d
movl %r8d, %esi
cmpq %rsi, %rdx
jbe 0xb246
leal 0x1(%rsi), %r8d
cmpq %rdi, (%rax,%rsi,8)
jne 0xb223
movq -0x8(%rax,%rcx), %rcx
movq %rcx, (%rax,%rsi,8)
addq $-0x8, 0xcdc52(%rip)    # 0xd8e98
popq %rbp
retq