LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xb0075(%rip), %rdi     # 0x15efd8
leaq 0x42cc5(%rip), %rsi     # 0xf1c2f
callq 0x5330
leaq 0xb17d2(%rip), %rdi     # 0x160748
callq 0xbe050
leaq 0xb1796(%rip), %rdi     # 0x160718
callq 0xbe090
leaq 0xb17ea(%rip), %rdi     # 0x160778
callq 0xbe0d0
leaq 0xb180e(%rip), %rdi     # 0x1607a8
callq 0xbe110
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xaf0e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xaf6b0
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e1f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e220
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xbe150
testb $0x1, %al
jne 0xaeff5
jmp 0xaf075
leaq -0x18(%rbp), %rdi
callq 0xbe190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xaf01f
jmp 0xaf015
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xaf031
jmp 0xaf043
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
callq 0xb00e0
jmp 0xaf065
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
callq 0xb08e0
jmp 0xaf065
movq 0xaff8e(%rip), %rdi     # 0x15efd8
leaq 0x4202d(%rip), %rsi     # 0xf107e
callq 0x5330
movq %rax, %rdi
movq 0xaff60(%rip), %rsi     # 0x15efc0
callq 0x53a0
jmp 0xaf067
leaq -0x18(%rbp), %rdi
callq 0xbe1b0
jmp 0xaefdf
leaq 0xb1654(%rip), %rdi     # 0x1606d0
callq 0xa01e0
movl %eax, %esi
leaq 0xb1646(%rip), %rdi     # 0x1606d0
callq 0xbe1d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xb1680
leaq 0xb16a5(%rip), %rdi     # 0x160748
callq 0xbe3d0
leaq 0xb1669(%rip), %rdi     # 0x160718
callq 0xbe430
leaq 0xb16bd(%rip), %rdi     # 0x160778
callq 0xbe490
leaq 0xb16e1(%rip), %rdi     # 0x1607a8
callq 0xbe4f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x55d0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0x40486(%rip), %rsi     # 0xf1c2f
callq 0x19840
jmp 0xb17b0
leaq -0xa(%rbp), %rdi
callq 0x53c0
leaq 0xaef40(%rip), %rax     # 0x160700
movq %rax, -0x28(%rbp)
leaq 0xaef35(%rip), %rdi     # 0x160700
callq 0xc1fd0
movq %rax, -0x30(%rbp)
leaq 0xaef25(%rip), %rdi     # 0x160700
callq 0xc2000
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc2030
testb $0x1, %al
jne 0xb17fa
jmp 0xb189c
leaq -0x30(%rbp), %rdi
callq 0xc2070
movq -0x90(%rbp), %rsi
movq %rax, -0x40(%rbp)
leaq 0x3f8eb(%rip), %rdx     # 0xf1100
leaq -0x80(%rbp), %rdi
callq 0x458c0
jmp 0xb1820
movq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1a4d0
jmp 0xb1833
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5420
leaq -0x60(%rbp), %rdi
callq 0x5200
leaq -0x80(%rbp), %rdi
callq 0x5200
leaq -0x30(%rbp), %rdi
callq 0xc2090
jmp 0xb17e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x53c0
jmp 0xb18ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xb18c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5200
jmp 0xb18c2
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xb18b2
movq -0x90(%rbp), %rdi
callq 0x5200
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x5200
movq -0x18(%rbp), %rdi
callq 0x55b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xc3500
testb $0x1, %al
jne 0xbe65a
jmp 0xbe663
movb $0x0, -0x1(%rbp)
jmp 0xbe7b4
movq -0x50(%rbp), %rdi
callq 0xc2a00
subq $0x1, %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xbe7b0
testb $0x1, -0x19(%rbp)
jne 0xbe6a5
movq -0x50(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x18, %rdi
callq 0xc2c10
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl (%rcx), %eax
jge 0xbe6a5
jmp 0xbe7b0
movq -0x50(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc3520
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x19db0
movb %al, %cl
movb $0x0, -0x41(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0xbe77a
movq -0x50(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc3520
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
movslq -0x20(%rbp), %rsi
callq 0xc3520
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
movb %al, -0x56(%rbp)
je 0xbe774
movq -0x50(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc3520
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
movslq -0x20(%rbp), %rsi
callq 0xc3520
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x68(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x5380
movb $0x1, -0x41(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x19db0
movb %al, -0x56(%rbp)
movb -0x56(%rbp), %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
movb %al, -0x69(%rbp)
testb $0x1, -0x41(%rbp)
jne 0xbe788
jmp 0xbe791
leaq -0x40(%rbp), %rdi
callq 0x5200
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xbe79a
jmp 0xbe7a0
movb $0x1, -0x1(%rbp)
jmp 0xbe7b4
jmp 0xbe7a2
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xbe673
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: pl0_env<func>::depth(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int pl0_env<T>::depth(std::string const & name) {
    if (tb.empty()) { return -1; } // doesn't exist.
    for (int i = this->tb.size()-1; i >= 0; --i) {
        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)) {
            for (int j = this->tags.size()-1; j >= 0; --j) {
                if (i >= this->tags[j]) {
                    return j;
                }
            }
        }
    }
    return -1; // NOT FOUND
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xc4d80
testb $0x1, %al
jne 0xbf2d3
jmp 0xbf2df
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbf457
movq -0x50(%rbp), %rdi
callq 0xc31e0
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xbf450
movq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x19db0
movb %al, %cl
movb $0x0, -0x41(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0xbf3ce
movq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xc4d60
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
movb %al, -0x52(%rbp)
je 0xbf3c8
movq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc4d60
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x68(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x5380
movb $0x1, -0x41(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x19db0
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
movb %al, -0x69(%rbp)
testb $0x1, -0x41(%rbp)
jne 0xbf3dc
jmp 0xbf3e5
leaq -0x40(%rbp), %rdi
callq 0x5200
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xbf3ee
jmp 0xbf440
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0xc2e90
subq $0x1, %rax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0xbf43e
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x70(%rbp)
addq $0x18, %rdi
movslq -0x48(%rbp), %rsi
callq 0xbfc00
movq %rax, %rcx
movl -0x70(%rbp), %eax
cmpl (%rcx), %eax
jl 0xbf431
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbf457
jmp 0xbf433
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xbf402
jmp 0xbf440
jmp 0xbf442
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbf2ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xc4d40
testb $0x1, %al
jne 0xbf711
jmp 0xbf71a
movb $0x0, -0x1(%rbp)
jmp 0xbf884
movq -0x60(%rbp), %rdi
callq 0xc31e0
subq $0x1, %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xbf880
testb $0x1, -0x19(%rbp)
jne 0xbf75c
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0x18, %rdi
callq 0xc2c10
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl (%rcx), %eax
jge 0xbf75c
jmp 0xbf880
movq -0x60(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x19db0
movb %al, %cl
movb $0x0, -0x51(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x65(%rbp)
jne 0xbf831
movq -0x60(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x60(%rbp), %rdi
movq %rax, -0x70(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq -0x70(%rbp), %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
movb %al, -0x66(%rbp)
je 0xbf82b
movq -0x60(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq -0x60(%rbp), %rdi
movq %rax, -0x78(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rdi
movl $0x5f, %esi
movq $-0x1, %rdx
callq 0x5640
movq -0x78(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
leaq -0x50(%rbp), %rdi
movq $-0x1, %rcx
callq 0x5380
movb $0x1, -0x51(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x19db0
movb %al, -0x66(%rbp)
movb -0x66(%rbp), %al
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
movb %al, -0x79(%rbp)
testb $0x1, -0x51(%rbp)
jne 0xbf83f
jmp 0xbf848
leaq -0x50(%rbp), %rdi
callq 0x5200
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xbf851
jmp 0xbf870
movq -0x60(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc4d60
movq %rax, %rsi
movq -0x28(%rbp), %rdi
callq 0xc6be0
movb $0x1, -0x1(%rbp)
jmp 0xbf884
jmp 0xbf872
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbf72a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0xc09ca
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xa3920
jmp 0xc09db
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x5150
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
callq 0xcd170
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xca5b5
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xa0(%rbp)
callq 0xccfb0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xcd1d0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xccfe0
jmp 0xca58a
leaq -0x78(%rbp), %rdi
callq 0xcd100
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xca5ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xcd100
jmp 0xca5da
movq -0x90(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
callq 0xcd290
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xcd460
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x78, %rdi
callq 0xcd4c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xcd490
testb $0x1, %al
jne 0xca643
jmp 0xca681
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xcd290
movl -0x5c(%rbp), %ecx
movq -0x58(%rbp), %rdi
movl %ecx, (%rax)
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0xcd130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xcd4f0
jmp 0xca7d3
leaq -0x20(%rbp), %rdi
callq 0xcd520
movl 0x48(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xca697
jmp 0xca7d3
movq -0x58(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd520
movq -0x68(%rbp), %rdi
movslq 0x48(%rax), %rsi
callq 0xcd130
movq %rax, %rdi
addq $0x18, %rdi
callq 0xcd540
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd520
movq -0x70(%rbp), %rdi
movslq 0x48(%rax), %rsi
callq 0xcd130
movq %rax, %rdi
addq $0x18, %rdi
callq 0xcd5b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xcd570
testb $0x1, %al
jne 0xca711
jmp 0xca792
leaq -0x30(%rbp), %rdi
callq 0xcd5e0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcd600
testb $0x1, %al
jne 0xca72c
jmp 0xca77e
movq -0x58(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd520
movq -0x80(%rbp), %rdi
movslq 0x48(%rax), %rsi
callq 0xcd130
addq $0x18, %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcd710
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xcd6a0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xca78d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xcd750
movq %rax, -0x50(%rbp)
jmp 0xca6c9
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xcd290
movl -0x84(%rbp), %ecx
movq -0x58(%rbp), %rdi
movl %ecx, (%rax)
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0xcd130
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xcd4f0
jmp 0xca7d3
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x108(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x100(%rbp)
addq $0x60, %rdi
callq 0xcd370
movq -0x100(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x60, %rdi
callq 0xcd3a0
movq -0x108(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rsi, -0x58(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xcaa00
movq -0x100(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x60, %rdi
callq 0xcd3a0
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcd3d0
testb $0x1, %al
jne 0xca8a1
jmp 0xca8ca
movq -0x100(%rbp), %rdi
addq $0x60, %rdi
callq 0xcd370
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xcd410
movl %eax, -0x4(%rbp)
jmp 0xca9db
movq -0x100(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x120(%rbp)
callq 0xccfb0
movq -0x108(%rbp), %rsi
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x5150
movl -0x114(%rbp), %esi
movq -0x110(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
leaq -0xc8(%rbp), %rdi
callq 0xcd060
jmp 0xca92e
movq -0x120(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xccfe0
jmp 0xca943
leaq -0xc8(%rbp), %rdi
callq 0xcd100
leaq -0xe8(%rbp), %rdi
callq 0x5200
movq -0x100(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xcd130
movq %rax, %rdi
callq 0xcd150
movq -0x100(%rbp), %rdi
addq $0x60, %rdi
movslq -0x28(%rbp), %rsi
callq 0xcd130
movq %rax, %rdi
callq 0xcd150
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xca9db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0xca9cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xcd100
leaq -0xe8(%rbp), %rdi
callq 0x5200
jmp 0xca9e7
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xcdfc0
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcdfc0
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp), %r8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xcbe90
jmp 0xcbd56
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0xcdfe0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0xce010
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xce040
testb $0x1, %al
jne 0xcbda3
jmp 0xcbe56
leaq -0x98(%rbp), %rdi
callq 0xce080
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xce0a0
movq %rax, -0xc0(%rbp)
jmp 0xcbdd6
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0xc9900
jmp 0xcbdeb
movq -0xa8(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xce0a0
movq %rax, -0xd0(%rbp)
jmp 0xcbe0b
movq -0xd0(%rbp), %rsi
movq -0xd8(%rbp), %rdi
callq 0xc9930
jmp 0xcbe20
jmp 0xcbe22
leaq -0x98(%rbp), %rdi
callq 0xce180
jmp 0xcbd87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xce1d0
leaq -0x48(%rbp), %rdi
callq 0xce1d0
jmp 0xcbe86
movq -0x10(%rbp), %rdi
callq 0xce1a0
movl %eax, -0xdc(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xce1d0
leaq -0x48(%rbp), %rdi
callq 0xce1d0
movl -0xdc(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x55b0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xcd68d
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xcd660
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x21(%rbp)
je 0xcd656
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xcd68b
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x22(%rbp)
je 0xcd683
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x19db0
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xcd68d
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, -0x11(%rbp)
je 0xd8c32
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0xc0, %rdi
callq 0xdaa70
testb $0x1, (%rax)
je 0xd8c2d
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0xc0, %rdi
callq 0xdaa70
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movb $0x0, (%rax)
addq $0xf0, %rdi
callq 0xdaca0
jmp 0xd8ccd
movq -0x40(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdacd0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdad00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdad30
testb $0x1, %al
jne 0xd8c6d
jmp 0xd8ccb
leaq -0x28(%rbp), %rdi
callq 0xdad60
movq -0x48(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x19db0
testb $0x1, %al
jne 0xd8c91
jmp 0xd8cbe
movq -0x40(%rbp), %rdi
addq $0xc0, %rdi
movq -0x38(%rbp), %rsi
callq 0xdaa70
movq -0x40(%rbp), %rdi
movb $0x0, (%rax)
addq $0xf0, %rdi
movq -0x38(%rbp), %rsi
callq 0xdaca0
jmp 0xd8ccb
jmp 0xd8cc0
leaq -0x28(%rbp), %rdi
callq 0xdad80
jmp 0xd8c5a
jmp 0xd8ccd
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0xc0, %rdi
callq 0xdaa70
testb $0x1, (%rax)
je 0xd9786
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0xf0, %rdi
callq 0xdab50
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5150
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0xd971b
leaq -0x30(%rbp), %rdi
callq 0x5200
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5150
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xd974d
leaq -0x60(%rbp), %rdi
callq 0x5200
jmp 0xd9788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5200
jmp 0xd9791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5200
jmp 0xd9791
jmp 0xd9788
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x55b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdx, -0x120(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5490
movq -0x120(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5150
jmp 0xda025
movq -0x128(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xda8d0
jmp 0xda03b
movq -0x138(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5420
movq %rax, %rdi
callq 0x54e0
movq %rax, -0x140(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5200
leaq -0x60(%rbp), %rdi
callq 0x5200
movq -0x140(%rbp), %rax
cmpq $0x0, %rax
jne 0xda1bc
leaq -0xb8(%rbp), %rdi
callq 0xda9d0
jmp 0xda08b
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %edx
leaq -0xb8(%rbp), %rcx
callq 0xdaf80
jmp 0xda0b0
movq -0x120(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x5150
jmp 0xda0c5
movq -0x128(%rbp), %rsi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rdx
callq *%rax
jmp 0xda0e5
leaq 0x1737f(%rip), %rsi     # 0xf146b
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0x19ad0
jmp 0xda101
movq -0x138(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x5420
leaq -0xd8(%rbp), %rdi
callq 0x5200
leaq -0xf8(%rbp), %rdi
callq 0x5200
leaq -0x118(%rbp), %rdi
callq 0x5200
leaq -0xb8(%rbp), %rdi
callq 0xdac70
jmp 0xda1bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xda1e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5200
jmp 0xda1e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xda1ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xda1a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x5200
leaq -0x118(%rbp), %rdi
callq 0x5200
leaq -0xb8(%rbp), %rdi
callq 0xdac70
jmp 0xda1e2
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xda1d2
movq -0x138(%rbp), %rdi
callq 0x5200
movq -0x130(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x5200
movq -0x68(%rbp), %rdi
callq 0x55b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdacd0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdad00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdad30
testb $0x1, %al
jne 0xda92e
jmp 0xda96e
leaq -0x28(%rbp), %rdi
callq 0xdad60
movq -0x68(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x19db0
testb $0x1, %al
jne 0xda952
jmp 0xda961
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5150
jmp 0xda9b3
jmp 0xda963
leaq -0x28(%rbp), %rdi
callq 0xdad80
jmp 0xda91b
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x55d0
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x172a5(%rip), %rsi     # 0xf1c2f
callq 0x19840
jmp 0xda991
leaq -0x39(%rbp), %rdi
callq 0x53c0
jmp 0xda9b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x53c0
jmp 0xda9bd
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_x86.cpp
// Function: pl0_x86_gen_param(std::vector<TAC, std::allocator<TAC>>&, unsigned long)
static size_t pl0_x86_gen_param(std::vector<TAC> & code, size_t p = 0) {
    int size = 8; // the first argument: ebp+8
    while (code[p].op == "param" || code[p].op == "paramref") {
        runtime.push(LOC(code[p].rd->sv, size, code[p].op == "paramref"));
        p = p + 1; size = size + 4;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcceb0
movq %rax, %rdi
leaq 0x1065a(%rip), %rsi     # 0xf110b
callq 0x2a580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x8d(%rbp)
jne 0xe0ae7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcceb0
movq %rax, %rdi
leaq 0x10626(%rip), %rsi     # 0xf1102
callq 0x2a580
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0xe0af6
jmp 0xe0bda
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcceb0
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq -0x80(%rbp), %rdi
callq 0x5150
movl -0x14(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcceb0
movq %rax, %rdi
leaq 0x105ce(%rip), %rsi     # 0xf1102
callq 0x2a580
movb %al, -0x8e(%rbp)
jmp 0xe0b41
movl -0x94(%rbp), %edx
movb -0x8e(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xdb170
jmp 0xe0b62
leaq 0x7fcb7(%rip), %rdi     # 0x160820
leaq -0x60(%rbp), %rsi
callq 0xdb140
jmp 0xe0b74
leaq -0x60(%rbp), %rdi
callq 0xdac70
leaq -0x80(%rbp), %rdi
callq 0x5200
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0xe0a9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xe0bcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xdac70
leaq -0x80(%rbp), %rdi
callq 0x5200
jmp 0xe0be7
movq -0x10(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x74f2a(%rip), %rdi     # 0x15efd8
leaq 0x76dc(%rip), %rsi      # 0xf1791
callq 0x5330
movq %rax, %rdi
movq 0x74efc(%rip), %rsi     # 0x15efc0
callq 0x53a0
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xde890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xde640
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xea8e0
testb $0x1, %al
jne 0xea101
jmp 0xea189
leaq -0x18(%rbp), %rdi
callq 0xdef00
movq %rax, -0x28(%rbp)
movq 0x74ec3(%rip), %rdi     # 0x15efd8
leaq 0x7671(%rip), %rsi      # 0xf178d
callq 0x5330
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xea920
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x52e0
movq %rax, -0x68(%rbp)
jmp 0xea149
movq -0x68(%rbp), %rdi
movq 0x74e6c(%rip), %rsi     # 0x15efc0
callq 0x53a0
jmp 0xea15b
leaq -0x48(%rbp), %rdi
callq 0x5200
leaq -0x18(%rbp), %rdi
callq 0xeab70
jmp 0xea0eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5200
jmp 0xea1b4
movq 0x74e48(%rip), %rdi     # 0x15efd8
leaq 0x7632(%rip), %rsi      # 0xf17c9
callq 0x5330
movq %rax, %rdi
movq 0x74e1a(%rip), %rsi     # 0x15efc0
callq 0x53a0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x55b0
nopl (%rax)
// File: 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
movl $0x52, %edi
callq 0x3bf22
testb $0x1, %al
jne 0xa944
jmp 0xa949
callq 0x18630
callq 0xe470
callq 0x18b20
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jb 0xb7a3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb881
movss -0x10(%rbp), %xmm0
movss 0x99860(%rip), %xmm1    # 0xa5010
ucomiss %xmm1, %xmm0
jbe 0xb7c0
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb881
movss -0x10(%rbp), %xmm2
movss 0x99843(%rip), %xmm0    # 0xa5010
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
movzbl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm3
movzbl -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm4
mulss %xmm4, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
cvttss2si %xmm1, %eax
movb %al, -0x4(%rbp)
movss -0x10(%rbp), %xmm2
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
movzbl -0x7(%rbp), %eax
cvtsi2ss %eax, %xmm3
movzbl -0xb(%rbp), %eax
cvtsi2ss %eax, %xmm4
mulss %xmm4, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
cvttss2si %xmm1, %eax
movb %al, -0x3(%rbp)
movss -0x10(%rbp), %xmm2
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
movzbl -0x6(%rbp), %eax
cvtsi2ss %eax, %xmm3
movzbl -0xa(%rbp), %eax
cvtsi2ss %eax, %xmm4
mulss %xmm4, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
cvttss2si %xmm1, %eax
movb %al, -0x2(%rbp)
movss -0x10(%rbp), %xmm1
subss %xmm1, %xmm0
movzbl -0x5(%rbp), %eax
cvtsi2ss %eax, %xmm2
movzbl -0x9(%rbp), %eax
cvtsi2ss %eax, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0x1(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xe620
movq -0x78(%rbp), %rax
leaq 0xdbf68(%rip), %rcx     # 0xe7a18
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9f60
movq -0x68(%rbp), %rdx
leaq 0x9969d(%rip), %rsi     # 0xa5170
leaq -0x38(%rbp), %rdi
callq 0x9b20
jmp 0xbade
movq -0x70(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x15d20
jmp 0xbaf6
leaq -0x38(%rbp), %rdi
callq 0x9530
leaq -0x39(%rbp), %rdi
callq 0x9960
movq -0x78(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x2c0(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x2c4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x2c8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x2cc(%rax)
cvtsi2ssl -0x14(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movq -0x5c(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x54(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl $0x0, 0x2d0(%rax)
movl $0x0, 0x2d4(%rax)
movb $0x0, 0x2d8(%rax)
movb $0x1, 0x2d9(%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x2e0(%rax)
movss 0x995b7(%rip), %xmm0    # 0xa5144
movss %xmm0, 0x2dc(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x2e4(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x2e8(%rax)
movl $0x1, 0x2ec(%rax)
movl $0x1, 0x2f0(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xbbeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9530
leaq -0x39(%rbp), %rdi
callq 0x9960
movq -0x78(%rbp), %rdi
callq 0xe660
movq -0x48(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cvtsi2ssl 0x2c0(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
cvtsi2ssl 0x2c4(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x14(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq %rax, %rdi
addq $0x8, %rdi
movl 0x2e0(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x16050
movq -0x20(%rbp), %rax
movl $0x0, 0x2d4(%rax)
movl $0x0, 0x2d0(%rax)
movl 0x2c0(%rax), %ecx
movl %ecx, 0x2c8(%rax)
movl 0x2c4(%rax), %ecx
movl %ecx, 0x2cc(%rax)
movb $0x0, 0x2d8(%rax)
movb $0x0, 0xdea5f(%rip)     # 0xeae89
movb $0x1, 0x2d9(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::SetState(Game::State)
void SetState(State state){
        stateTimer = 0;
        switch(state){
            case Intro:
            break;

            case Menu:
                MenuStateInit();
                stateUpdateFunction = MenuStateUpdate;
            break;

            case GameStart:
                GameStartStateInit();    
                stateUpdateFunction = GameStartStateUpdate;
            break;

            case GameInProgress:
                GameInProgressStateInit();
                stateUpdateFunction = GameInProgressStateUpdate;
            break;

             case LevelCleared:
                LevelClearedStateInit();
                stateUpdateFunction = LevelClearedStateUpdate;
            break;

            case GameOver:
                GameOverStateInit();
                stateUpdateFunction = GameOverStateUpdate;
            break;

        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, 0xdd9ba(%rip) # 0xeaea0
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x5, %rax
ja 0xd570
movq -0x10(%rbp), %rax
leaq 0x97cca(%rip), %rcx     # 0xa51c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd570
callq 0xd5c0
leaq 0x17b(%rip), %rax       # 0xd690
movq %rax, 0xdd99c(%rip)     # 0xeaeb8
jmp 0xd570
callq 0xd800
leaq 0x366(%rip), %rax       # 0xd890
movq %rax, 0xdd987(%rip)     # 0xeaeb8
jmp 0xd570
callq 0xd9c0
leaq 0x4a1(%rip), %rax       # 0xd9e0
movq %rax, 0xdd972(%rip)     # 0xeaeb8
jmp 0xd570
callq 0xdd30
leaq 0x7ec(%rip), %rax       # 0xdd40
movq %rax, 0xdd95d(%rip)     # 0xeaeb8
jmp 0xd570
callq 0xdf80
leaq 0xa27(%rip), %rax       # 0xdf90
movq %rax, 0xdd948(%rip)     # 0xeaeb8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
callq 0xe4a0
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9f60
movq -0x68(%rbp), %rdx
leaq 0x97bc0(%rip), %rsi     # 0xa5275
leaq -0x20(%rbp), %rdi
callq 0x9b20
jmp 0xd6c0
leaq -0x20(%rbp), %rdi
movss 0x97b14(%rip), %xmm0    # 0xa51e0
movss 0x97b10(%rip), %xmm1    # 0xa51e4
movss 0x97b0c(%rip), %xmm3    # 0xa51e8
movaps %xmm3, %xmm2
callq 0x1a590
jmp 0xd6e6
leaq -0x20(%rbp), %rdi
callq 0x9530
leaq -0x21(%rbp), %rdi
callq 0x9960
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9f60
movq -0x70(%rbp), %rdx
leaq 0x97b80(%rip), %rsi     # 0xa5290
leaq -0x58(%rbp), %rdi
callq 0x9b20
jmp 0xd71b
movb $-0xa, -0x5d(%rbp)
movb $-0x3c, -0x5c(%rbp)
movb $0x2, -0x5b(%rbp)
movb $-0x1, -0x5a(%rbp)
movl -0x5d(%rbp), %esi
leaq -0x58(%rbp), %rdi
movss 0x97aa6(%rip), %xmm0    # 0xa51e0
movss 0x97aaa(%rip), %xmm1    # 0xa51ec
movss 0x97aa6(%rip), %xmm2    # 0xa51f0
xorps %xmm3, %xmm3
callq 0x1a750
jmp 0xd754
leaq -0x58(%rbp), %rdi
callq 0x9530
leaq -0x59(%rbp), %rdi
callq 0x9960
movl $0x20, %edi
callq 0x3bf80
testb $0x1, %al
jne 0xd776
jmp 0xd7ef
movq 0xdd71b(%rip), %rdi     # 0xeae98
callq 0x141d0
callq 0xe5a0
movl $0x2, %edi
callq 0xd4d0
jmp 0xd7ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd7b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9530
leaq -0x21(%rbp), %rdi
callq 0x9960
jmp 0xd7f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd7e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9530
leaq -0x59(%rbp), %rdi
callq 0x9960
jmp 0xd7f5
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9f50
nop
// File: 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
subq $0x70, %rsp
movsd 0x97970(%rip), %xmm0    # 0xa5210
ucomisd 0xdd5f8(%rip), %xmm0    # 0xeaea0
jbe 0xd99b
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9f60
movq -0x68(%rbp), %rdx
leaq 0x979fc(%rip), %rsi     # 0xa52c2
leaq -0x20(%rbp), %rdi
callq 0x9b20
jmp 0xd8d1
movb $-0x1, -0x38(%rbp)
movb $-0x1, -0x37(%rbp)
movb $-0x1, -0x36(%rbp)
movb $-0x1, -0x35(%rbp)
movl -0x38(%rbp), %esi
leaq -0x20(%rbp), %rdi
movss 0x978f0(%rip), %xmm0    # 0xa51e0
movss 0x978ec(%rip), %xmm1    # 0xa51e4
movss 0x978f0(%rip), %xmm2    # 0xa51f0
xorps %xmm3, %xmm3
callq 0x1a750
jmp 0xd90a
leaq -0x20(%rbp), %rdi
callq 0x9530
leaq -0x21(%rbp), %rdi
callq 0x9960
callq 0xe4a0
callq 0x106c0
movlpd %xmm0, -0x40(%rbp)
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x4c(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
movss 0x977de(%rip), %xmm2    # 0xa5144
callq 0x188d0
jmp 0xd9a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd990
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9530
leaq -0x21(%rbp), %rdi
callq 0x9960
jmp 0xd9ab
movl $0x3, %edi
callq 0xd4d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)