LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: phillip-h[P]todo/src/task.cpp
// Function: Task::save[abi:cxx11]()
string Task::save()
{
    string value = "";
    
    value += name;
    value += ":";
    
    value += std::to_string(complete);
    
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4690
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x57c7(%rip), %rsi      # 0x1244a
callq 0x85c0
jmp 0xcc8a
leaq -0x12(%rbp), %rdi
callq 0x43d0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x44c0
jmp 0xcca2
movq -0x58(%rbp), %rdi
leaq 0x591c(%rip), %rsi      # 0x125c9
callq 0x4320
jmp 0xccb4
movq -0x60(%rbp), %rax
movzbl 0x20(%rax), %esi
andl $0x1, %esi
leaq -0x48(%rbp), %rdi
callq 0xd0c0
jmp 0xccca
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x44c0
jmp 0xccd9
leaq -0x48(%rbp), %rdi
callq 0x4738
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xcd33
jmp 0xcd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x43d0
jmp 0xcd46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xcd3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4738
jmp 0xcd3d
movq -0x58(%rbp), %rdi
callq 0x4738
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4738
movq -0x20(%rbp), %rdi
callq 0x4680
nop
// File: phillip-h[P]todo/src/task.cpp
// Function: Task::parse()
Task Task::parse()
{
    for (unsigned i = 0; i < name.size() - 1; i++){
        if (name.substr(name.size() - i - 1, 1) == ":"){
            if (name.substr(name.size() - i, 1) == "1"){
                complete = true;
            }
            
            name = name.substr(0, name.size() - i - 1);
            return *this;
        }
    }
    
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x90(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0xa8(%rbp)
callq 0x4270
movq %rax, %rcx
movq -0xa8(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xcf2f
movq -0x90(%rbp), %rdi
callq 0x4270
movq -0x90(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl %ecx, %edx
notq %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x1, %ecx
callq 0x4370
movq -0xb8(%rbp), %rdi
leaq 0x57d5(%rip), %rsi      # 0x125c9
callq 0x8670
movb %al, -0xa9(%rbp)
jmp 0xce01
leaq -0x38(%rbp), %rdi
callq 0x4738
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xce19
jmp 0xcf1f
movq -0x90(%rbp), %rdi
callq 0x4270
movq -0x90(%rbp), %rsi
movq %rax, %rdx
movl -0x14(%rbp), %eax
subq %rax, %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x1, %ecx
callq 0x4370
movq -0xc8(%rbp), %rdi
leaq 0x51ae(%rip), %rsi      # 0x12006
callq 0x8670
movb %al, -0xb9(%rbp)
jmp 0xce65
leaq -0x68(%rbp), %rdi
callq 0x4738
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0xce7a
jmp 0xcebb
movq -0x90(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0xcebb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4738
jmp 0xcf52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4738
jmp 0xcf52
movq -0x90(%rbp), %rdi
callq 0x4270
movq -0x90(%rbp), %rsi
movq %rax, %rcx
movl -0x14(%rbp), %eax
subq %rax, %rcx
subq $0x1, %rcx
leaq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x4370
movq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4470
leaq -0x88(%rbp), %rdi
callq 0x4738
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xc690
jmp 0xcf42
jmp 0xcf21
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd86
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0xc690
movq -0x98(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4680
nopl (%rax,%rax)
// File: phillip-h[P]todo/src/todo.cpp
// Function: main
int main(int argv, char **argc)
{
    if (parseArgs(argv, argc)){
        return EXIT_NORMAL;
    }
  
    Draw::init(); 
    Core::init();

    TodoList *todoList = Core::list(name());
    unsigned position = 0;

    while(true){
        Draw::draw(todoList, position);
        if (Core::handleInput(getch(), todoList, position)){
            break;
        }
    }

    Draw::stop();
    Core::stop();

    todoList->save();
    delete todoList;

    return EXIT_NORMAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x65a0
testb $0x1, %al
jne 0xd208
jmp 0xd214
movl $0x0, -0x4(%rbp)
jmp 0xd2dc
callq 0xa7f0
callq 0x97c0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x82a0
movq -0x58(%rbp), %rdi
callq 0x9820
movq %rax, -0x50(%rbp)
jmp 0xd23a
leaq -0x38(%rbp), %rdi
callq 0x4738
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x48(%rbp), %esi
callq 0xade0
movq 0xad5b(%rip), %rax      # 0x17fc0
movq (%rax), %rdi
callq 0x4170
movl %eax, %edi
leaq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x98d0
testb $0x1, %al
jne 0xd282
jmp 0xd29b
jmp 0xd29d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4738
jmp 0xd2e5
jmp 0xd252
callq 0xc590
callq 0x97e0
movq -0x18(%rbp), %rdi
callq 0xd480
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xd2d5
movq -0x60(%rbp), %rdi
callq 0xd430
movq -0x60(%rbp), %rdi
movl $0x28, %esi
callq 0x4360
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4680
nop
// File: phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::save()
void TodoList::save()
{
    mkdir(getSaveDir().c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
    std::ofstream file(getPath());

    if (!file.good()){
        std::cout << "failed to write to-do list!\n";
        return;
    }

    for (unsigned i = 0; i < size(); i++){
        file << at(i).save() << "\n";
    }

    file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0xd6c0
movq -0x298(%rbp), %rdi
callq 0x41b0
movq %rax, %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x41e0
movq -0x298(%rbp), %rdi
callq 0x4738
movq -0x290(%rbp), %rsi
leaq -0x248(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0xd7b0
movq -0x288(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x46f0
jmp 0xd503
leaq -0x248(%rbp), %rdi
callq 0x4738
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x4640
movb %al, -0x299(%rbp)
jmp 0xd52f
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0xd599
jmp 0xd53b
movq 0xaa86(%rip), %rdi      # 0x17fc8
leaq 0x5087(%rip), %rsi      # 0x125d0
callq 0x4340
jmp 0xd550
movl $0x1, -0x258(%rbp)
jmp 0xd690
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x4738
jmp 0xd6b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0xd6a5
movl $0x0, -0x25c(%rbp)
movq -0x290(%rbp), %rdi
movl -0x25c(%rbp), %eax
movl %eax, -0x2a4(%rbp)
callq 0xd9c0
movl %eax, -0x2a0(%rbp)
jmp 0xd5c3
movl -0x2a4(%rbp), %eax
movl -0x2a0(%rbp), %ecx
cmpl %ecx, %eax
jae 0xd678
movq -0x290(%rbp), %rdi
movl -0x25c(%rbp), %esi
callq 0xd9e0
movq %rax, -0x2b0(%rbp)
jmp 0xd5f2
movq -0x2b0(%rbp), %rsi
leaq -0x280(%rbp), %rdi
callq 0xcc40
jmp 0xd607
leaq -0x228(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x4300
movq %rax, -0x2b8(%rbp)
jmp 0xd623
movq -0x2b8(%rbp), %rdi
leaq 0x4ab8(%rip), %rsi      # 0x120e9
callq 0x4340
jmp 0xd638
leaq -0x280(%rbp), %rdi
callq 0x4738
movl -0x25c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x25c(%rbp)
jmp 0xd5a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4738
jmp 0xd6a5
leaq -0x228(%rbp), %rdi
callq 0x4520
jmp 0xd686
movl $0x0, -0x258(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x4540
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x4540
movq -0x250(%rbp), %rdi
callq 0x4680
nopl (%rax)
// File: phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::completed()
unsigned TodoList::completed()
{
    unsigned count = 0;
    for (unsigned i = 0; i < size(); i++){
        if (at(i).completed()){
            count++;
        }
    }

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xd9c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jae 0xde9a
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xd9e0
movq %rax, %rdi
callq 0xd010
testb $0x1, %al
jne 0xde84
jmp 0xde8d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xde8f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xde52
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::swap(unsigned int)
bool TodoList::swap(unsigned pos)
{
    if (pos >= size() - 1){
        return false; 
    }
    Task temp = taskList->at(pos);
    taskList->at(pos) = taskList->at(pos + 1);
    taskList->at(pos + 1) = temp;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x50(%rbp)
callq 0xd9c0
movl %eax, %ecx
movl -0x50(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jb 0xe207
movb $0x0, -0x1(%rbp)
jmp 0xe2b1
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8820
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xc690
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x8820
movq %rax, -0x60(%rbp)
jmp 0xe23d
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8820
movq %rax, -0x68(%rbp)
jmp 0xe254
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xe990
jmp 0xe263
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x8820
movq %rax, -0x70(%rbp)
jmp 0xe27c
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe990
jmp 0xe28b
movb $0x1, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa4d0
jmp 0xe2b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa4d0
jmp 0xe2bc
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::sort()
void TodoList::sort()
{
    unsigned pos = 0;
    for (unsigned i = 0; i < size(); i++){
        if (taskList->at(i).div()){
            std::sort(taskList->begin() + pos, taskList->begin() + i,
                      Task::cmp);
            pos = i + 1;
        } else if (i == size() - 1){
            std::sort(taskList->begin() + pos, taskList->end(),
                      Task::cmp);
            pos = i + 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x50(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0xd9c0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0xe412
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x8820
movq %rax, %rdi
callq 0xcf90
testb $0x1, %al
jne 0xe32d
jmp 0xe393
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0xe870
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0xe8a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0xe870
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xe8a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x1353(%rip), %rdx     # 0xd030
callq 0xea20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe402
movq -0x50(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x58(%rbp)
callq 0xd9c0
movl %eax, %ecx
movl -0x58(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe400
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0xe870
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0xe8a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
callq 0xea70
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x13c2(%rip), %rdx     # 0xd030
callq 0xea20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe402
jmp 0xe404
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe2f2
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: phillip-h[P]todo/src/win.cpp
// Function: Win::Win(unsigned int, unsigned int, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Win::Win(unsigned x, unsigned y, unsigned w, unsigned h, 
         string name, bool border)
{
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;

    this->name = name;

    this->border = newwin(h, w, y, x); 
    
    if (border)
        win = newwin(h - 2, w - 2, y + 1, x + 1);
    else
        win = newwin(h, w, y, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r9, -0x40(%rbp)
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x4500
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
callq 0x4060
jmp 0x119bd
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4380
movq %rax, -0x58(%rbp)
jmp 0x119d4
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x21(%rbp)
je 0x11a2b
movl -0x18(%rbp), %edi
addl $-0x2, %edi
movl -0x14(%rbp), %esi
addl $-0x2, %esi
movl -0x10(%rbp), %edx
incl %edx
movl -0xc(%rbp), %ecx
incl %ecx
callq 0x4380
movq %rax, -0x60(%rbp)
jmp 0x11a07
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x11a4d
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4738
jmp 0x11a53
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x4380
movq %rax, -0x68(%rbp)
jmp 0x11a42
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4680
nopl (%rax)
// File: phillip-h[P]todo/src/win.cpp
// Function: Win::draw()
void Win::draw()
{
    box(border, 0, 0);
    inverse(true);
    mvwprintw(border, 0, 0, string("[" + name + "]").c_str());
    inverseOff(true);
    wrefresh(border);
    wrefresh(win);    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x8(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x46c0
movq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x11c00
movq -0x70(%rbp), %rdx
movq 0x8(%rdx), %rax
movq %rax, -0x68(%rbp)
addq $0x20, %rdx
leaq 0x8f3(%rip), %rsi       # 0x12439
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa580
movq -0x60(%rbp), %rsi
leaq 0x4ac(%rip), %rdx       # 0x1200a
leaq -0x28(%rbp), %rdi
callq 0xa530
jmp 0x11b69
leaq -0x28(%rbp), %rdi
callq 0x41b0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
xorl %edx, %edx
movb %dl, %al
movl %edx, %esi
callq 0x4100
jmp 0x11b86
leaq -0x28(%rbp), %rdi
callq 0x4738
leaq -0x48(%rbp), %rdi
callq 0x4738
movq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x11c60
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4400
movq -0x70(%rbp), %rax
movq (%rax), %rdi
callq 0x4400
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x11be8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4738
leaq -0x48(%rbp), %rdi
callq 0x4738
movq -0x50(%rbp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: cla7aye15I4nd[P]basic_interpreter/./lib/basic.hpp
// Function: basic::to_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int to_int(const string& str) {
        int result = 0, sg = +1;
        for (size_t p = str[0] == '-' ? sg = -1, 1: 0; p < str.size(); ++p) {
            result = result * 10 + str[p] - '0';
        }
        return sg * result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32b0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3c20
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c27
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c27
movl -0x1c(%rbp), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c80
imull $0xa, -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32b0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c30
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cla7aye15I4nd[P]basic_interpreter/./lib/basic.hpp
// Function: basic::is_digit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_digit(const std::string& str) {
        if (str == "-") return false;
        for (size_t p = str[0] == '-'; p < str.size(); ++p)
            if (!isdigit(str[p])) return false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd391(%rip), %rsi      # 0x11038
callq 0x4080
testb $0x1, %al
jne 0x3cb2
jmp 0x3cb8
movb $0x0, -0x1(%rbp)
jmp 0x3d28
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32b0
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d24
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32b0
movsbl (%rax), %edi
callq 0x3210
cmpl $0x0, %eax
jne 0x3d14
movb $0x0, -0x1(%rbp)
jmp 0x3d28
jmp 0x3d16
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3cd7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cla7aye15I4nd[P]basic_interpreter/./lib/basic.hpp
// Function: basic::format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
expression format(const string& str) {
        expression result;
        string element;
    
        for (auto ptr = str.begin(); ptr != str.end(); ) {
            if (isspace(*ptr)) {
                ptr++;
                continue;
            }
            element = "";
            if (isalpha(*ptr)) {
                while (isalpha(*ptr))
                    element += *ptr++;
            } else if (isdigit(*ptr)) {
                while (isdigit(*ptr))
                    element += *ptr++;
            } else{
                element += *ptr++;
            }
            result.push_back(element);
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x40b0
leaq -0x38(%rbp), %rdi
callq 0x3340
movq -0x10(%rbp), %rdi
callq 0x3220
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3410
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x40d0
testb $0x1, %al
jne 0x3ec3
jmp 0x4016
leaq -0x40(%rbp), %rdi
callq 0x4110
movsbl (%rax), %edi
callq 0x3050
cmpl $0x0, %eax
je 0x3eea
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4130
movq %rax, -0x50(%rbp)
jmp 0x3ea0
leaq 0xd25a(%rip), %rsi      # 0x1114b
leaq -0x38(%rbp), %rdi
callq 0x3330
jmp 0x3efc
leaq -0x40(%rbp), %rdi
callq 0x4110
movsbl (%rax), %edi
callq 0x3380
cmpl $0x0, %eax
je 0x3f7d
jmp 0x3f14
leaq -0x40(%rbp), %rdi
callq 0x4110
movsbl (%rax), %edi
callq 0x3380
cmpl $0x0, %eax
je 0x3f78
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4130
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4110
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x3f50
jmp 0x3f14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x88(%rbp), %rdi
callq 0x41e0
jmp 0x4042
jmp 0x3fff
leaq -0x40(%rbp), %rdi
callq 0x4110
movsbl (%rax), %edi
callq 0x3210
cmpl $0x0, %eax
je 0x3fd5
jmp 0x3f95
leaq -0x40(%rbp), %rdi
callq 0x4110
movsbl (%rax), %edi
callq 0x3210
cmpl $0x0, %eax
je 0x3fd3
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4130
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4110
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x3fd1
jmp 0x3f95
jmp 0x3ffd
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4130
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4110
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x3ffb
jmp 0x3ffd
jmp 0x3fff
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4170
jmp 0x4011
jmp 0x3ea0
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
testb $0x1, -0x11(%rbp)
jne 0x4035
movq -0x88(%rbp), %rdi
callq 0x41e0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::execute(basic::basic_interpreter::step)
int execute(step s) {
            //step& s = program[line_number];

            switch (s.type) {
            case 4: return -1;
            case 5:
                ASSERT(program.count(to_int(s.expr[0])), LINE_NUMBER_ERROR);
                return to_int(s.expr[0]);
            case 1: assign(s.expr.begin(), s.expr.end()); break;
            case 6:
                if (compare(s.expr.begin(), s.expr.end() - 2))
                    return to_int(*s.expr.rbegin());
                break;
            case 2: print(eval(s.expr.begin(), s.expr.end())); break;
            case 3: input(*(s.expr.begin()));
            }

            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl (%rsi), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x70(%rbp)
subl $0x5, %eax
ja 0x668c
movq -0x70(%rbp), %rax
leaq 0xab2b(%rip), %rcx      # 0x11008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6693
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d00
movq %rax, %rdi
callq 0x3be0
movq -0x88(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x67f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x653c
jmp 0x6559
movl $0x1, %edi
callq 0x3110
movq %rax, %rdi
leaq 0x13848(%rip), %rsi     # 0x19d98
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d00
movq %rax, %rdi
callq 0x3be0
movl %eax, -0x4(%rbp)
jmp 0x6693
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x68c0
movq -0x80(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x68f0
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x6850
jmp 0x668c
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x68c0
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x68f0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x2, %esi
callq 0x6ac0
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x6920
testb $0x1, %al
jne 0x65fd
jmp 0x6624
movq -0x80(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x6b00
leaq -0x50(%rbp), %rdi
callq 0x6b50
movq %rax, %rdi
callq 0x3be0
movl %eax, -0x4(%rbp)
jmp 0x6693
jmp 0x668c
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x68c0
movq -0x80(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x68f0
movq -0x78(%rbp), %rdi
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x6bc0
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x6b80
jmp 0x668c
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x68c0
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6e70
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x6d90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void input(const string& name) {
            std::string content;

            do {
                std::cout << " ? ";
                std::getline(std::cin, content);
                if (is_digit(content))
                    break;
                std::cout << "INVALID NUMBER\n";
            } while (true);
            map[name] = to_int(content);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3340
movq 0x13218(%rip), %rdi     # 0x19fd0
leaq 0xa379(%rip), %rsi      # 0x11138
callq 0x3230
jmp 0x6dc6
movq 0x13213(%rip), %rdi     # 0x19fe0
leaq -0x30(%rbp), %rsi
callq 0x3080
jmp 0x6dd8
leaq -0x30(%rbp), %rdi
callq 0x3c90
movb %al, -0x49(%rbp)
jmp 0x6de6
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x6def
jmp 0x6e08
jmp 0x6e27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3160
jmp 0x6e5e
movq 0x131c1(%rip), %rdi     # 0x19fd0
leaq 0xa326(%rip), %rsi      # 0x1113c
callq 0x3230
jmp 0x6e1d
jmp 0x6e1f
movb $0x1, %al
testb $0x1, %al
jne 0x6db1
jmp 0x6e27
leaq -0x30(%rbp), %rdi
callq 0x3be0
movq -0x48(%rbp), %rdi
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7200
movq %rax, -0x58(%rbp)
jmp 0x6e46
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3160
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::eval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int eval(const string& str) {
            if (is_digit(str))
                return to_int(str); 
            ASSERT(map.count(str), VARIABLE_NOT_DEFINED);
            return map[str];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c90
testb $0x1, %al
jne 0x9b17
jmp 0x9b25
movq -0x18(%rbp), %rdi
callq 0x3be0
movl %eax, -0x4(%rbp)
jmp 0x9b67
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xad90
cmpq $0x0, %rax
jne 0x9b55
movl $0x1, %edi
callq 0x3110
movq %rax, %rdi
leaq 0x1023c(%rip), %rsi     # 0x19d88
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7200
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::operator<<(std::ostream&, basic::basic_interpreter::step const&)
std::ostream& operator<< (std::ostream &sout, const step& s) {
                sout << command[s.type];
                for (auto str : s.expr)
                    sout << ' ' << str;
                sout << std::endl;
                return sout;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rax
leaq 0xe65e(%rip), %rsi      # 0x1a2b0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3200
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb4b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb4e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb890
testb $0x1, %al
jne 0xbc97
jmp 0xbcfa
leaq -0x20(%rbp), %rdi
callq 0xb900
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x30e0
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x32e0
movq %rax, -0x60(%rbp)
jmp 0xbcc0
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3200
jmp 0xbccf
leaq -0x48(%rbp), %rdi
callq 0x3160
leaq -0x20(%rbp), %rdi
callq 0xb920
jmp 0xbc84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
jmp 0xbd14
movq -0x8(%rbp), %rdi
movq 0xe2bb(%rip), %rsi      # 0x19fc0
callq 0x3270
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: justinjo[P]Pacman/pacman.cpp
// Function: Pacman::Pacman()
Pacman::Pacman()
{
        center();
        alive = true;
        head = UP;
        num_moves = 0;
        score = 0;
        dots_eaten = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2660
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movb $0x76, 0x1(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: justinjo[P]Pacman/pacman.cpp
// Function: Pacman::rotate_head(char)
void Pacman::rotate_head(char command)
{
        if (command == CMD_UP){
                head = UP;
        } else if (command == CMD_DWN){
                head = DOWN;
        } else if (command == CMD_LFT){
                head = LEFT;
        } else if (command == CMD_RGT){
                head = RIGHT;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x77, %eax
jne 0x2849
movq -0x18(%rbp), %rax
movb $0x76, 0x1(%rax)
jmp 0x2886
movsbl -0x9(%rbp), %eax
cmpl $0x73, %eax
jne 0x285c
movq -0x18(%rbp), %rax
movb $0x5e, 0x1(%rax)
jmp 0x2884
movsbl -0x9(%rbp), %eax
cmpl $0x61, %eax
jne 0x286f
movq -0x18(%rbp), %rax
movb $0x3e, 0x1(%rax)
jmp 0x2882
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
jne 0x2880
movq -0x18(%rbp), %rax
movb $0x3c, 0x1(%rax)
jmp 0x2882
jmp 0x2884
jmp 0x2886
popq %rbp
retq
nopl (%rax,%rax)
// File: justinjo[P]Pacman/ghost.cpp
// Function: Ghost::set_random_location()
void Ghost::set_random_location()
{
        do {
                row = random_int(0, ROWS-1);
                col = random_int(0, COLS-1);
        } while (row == MIDROW || col == MIDCOL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %edi, %edi
movl $0x14, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
xorl %edi, %edi
movl $0x3c, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0xa, (%rcx)
movb %al, -0x11(%rbp)
je 0x2cb9
movq -0x10(%rbp), %rax
cmpl $0x1e, 0x4(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2c74
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: justinjo[P]Pacman/ghost.cpp
// Function: Ghost::move(char (*) [61], int, int)
bool Ghost::move(char board[ROWS][COLS], int target_r, int target_c)
{
        int new_row = row;
        int new_col = col; 
        board[row][col] = board_char;   // replace element of board
        if (abs(row-target_r) > abs(col-target_c)){     // never wraps
                if (row > target_r){
                        new_row--;
                } else if (row < target_r){
                        new_row++;
                }
                if (board[new_row][new_col] != GHOST)
                        row = new_row;
        } else {
                if (col > target_c){
                        new_col--;
                } else if (col < target_c){
                        new_col++;
                }
                if (board[new_row][new_col] != GHOST)
                        col = new_col;
        }
        place_on_board(board);
        return (target_r == row && target_c == col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl (%rcx), %eax
movl %eax, -0x1c(%rbp)
movl 0x4(%rcx), %eax
movl %eax, -0x20(%rbp)
movb 0x8(%rcx), %sil
movq -0x10(%rbp), %rax
movslq (%rcx), %rdx
imulq $0x3d, %rdx, %rdx
addq %rdx, %rax
movslq 0x4(%rcx), %rdx
movb %sil, (%rax,%rdx)
movl (%rcx), %eax
subl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jle 0x2d83
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x2d46
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d5c
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x2d5a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d5c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x3d, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6d, %eax
je 0x2d81
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x2dd9
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0x2d9a
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2db1
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jge 0x2daf
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2db1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x3d, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6d, %eax
je 0x2dd7
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x2dd9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e20
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x2e06
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::Game()
Game::Game()
{
        level = 1;
        level_over = false;
        game_won = false;

/*        pubnub::context pn("pub-c-211da9ce-adcf-44ab-b2d1-fc1c0a8eaadc", 
                        "sub-c-22d37992-dea5-11e6-b2ae-0619f8945a4f");        */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2620
movq -0x20(%rbp), %rax
addq $0x524, %rax            # imm = 0x524
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2c20
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0x2f09
movq -0x20(%rbp), %rax
addq $0x554, %rax            # imm = 0x554
movq %rax, %rcx
addq $0x258, %rcx            # imm = 0x258
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4430
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x2f47
movq -0x20(%rbp), %rax
addq $0x7ac, %rax            # imm = 0x7AC
movq %rax, %rcx
addq $0xa0, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x45a0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x48(%rbp)
jne 0x2f85
movq -0x20(%rbp), %rax
movl $0x1, 0x504(%rax)
movb $0x0, 0x508(%rax)
movb $0x0, 0x509(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::print_manual()
void Game::print_manual()
{
        screen_clear();
        cout << "PACMAN GAME\n"
                "            \n"
                " Move left:    " << CMD_LFT << "\n"
                " Move right:   " << CMD_RGT << "\n"
                " Move up:      " << CMD_UP  << "\n"
                " Move down:    " << CMD_DWN << "\n"
                "\n"
                " Collect all the dots. They look like: " << DOT << "\n"
                " Avoid the ghosts.     They look like: " << GHOST << "\n"
                "\n"
                " Good luck!\n"
                "\n"
                " Press any key to continue...\n";

        getachar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3e80
movq 0x4fe0(%rip), %rdi      # 0x7fc8
leaq 0x2015(%rip), %rsi      # 0x5004
callq 0x2120
movq %rax, %rdi
movl $0x61, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x2022(%rip), %rsi      # 0x502d
callq 0x2120
movq %rax, %rdi
movl $0x64, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x2017(%rip), %rsi      # 0x503e
callq 0x2120
movq %rax, %rdi
movl $0x77, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x200c(%rip), %rsi      # 0x504f
callq 0x2120
movq %rax, %rdi
movl $0x73, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x2001(%rip), %rsi      # 0x5060
callq 0x2120
movq %rax, %rdi
movl $0x6f, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x200f(%rip), %rsi      # 0x508a
callq 0x2120
movq %rax, %rdi
movl $0x6d, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x201c(%rip), %rsi      # 0x50b3
callq 0x2120
callq 0x3a30
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::run()
void Game::run()
{
        while (!game_won && p.is_alive()){
                reset_level();
                start_level();
                play_level();
                if (p.is_alive())
                        complete_level();
        }
        if (game_won){
                cout << "You win!\n";
        } else {
                cout << "You lost :(\n";
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x509(%rcx)
movb %al, -0x11(%rbp)
jne 0x30e9
movq -0x10(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2bc0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x30f2
jmp 0x312e
movq -0x10(%rbp), %rdi
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x3200
movq -0x10(%rbp), %rdi
callq 0x3270
movq -0x10(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2bc0
testb $0x1, %al
jne 0x3123
jmp 0x312c
movq -0x10(%rbp), %rdi
callq 0x34b0
jmp 0x30c4
movq -0x10(%rbp), %rax
testb $0x1, 0x509(%rax)
je 0x3150
movq 0x4e86(%rip), %rdi      # 0x7fc8
leaq 0x1f98(%rip), %rsi      # 0x50e1
callq 0x2120
jmp 0x3163
movq 0x4e71(%rip), %rdi      # 0x7fc8
leaq 0x1f8d(%rip), %rsi      # 0x50eb
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::reset_level()
void Game::reset_level()
{
        clear_board();
        init_dots();    // prepare dots, boulders, and ghosts
        set_dots();
        set_boulders();
        set_ghosts();
        p.center();     // prepare pacman
        p.place_on_board(board);
        p.set_dots(0);
        level_over = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3510
movq -0x10(%rbp), %rdi
callq 0x3720
movq -0x10(%rbp), %rdi
callq 0x37c0
movq -0x10(%rbp), %rdi
callq 0x36c0
movq -0x10(%rbp), %rdi
callq 0x38c0
movq -0x10(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2660
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2a70
movq -0x10(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
xorl %esi, %esi
callq 0x2be0
movq -0x10(%rbp), %rax
movb $0x0, 0x508(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::start_level()
void Game::start_level()
{
        screen_clear();
        print_board();
        cout << "Level " << level << ": Press any key to start\n";
        getachar();
        screen_clear(); // print initial state of boar
        print_board(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x3e80
movq -0x10(%rbp), %rdi
callq 0x3570
movq 0x4d9f(%rip), %rdi      # 0x7fc8
leaq 0x1ed0(%rip), %rsi      # 0x5100
callq 0x2120
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x504(%rax), %esi
callq 0x2270
movq %rax, %rdi
leaq 0x1eb6(%rip), %rsi      # 0x5107
callq 0x2120
callq 0x3a30
callq 0x3e80
movq -0x10(%rbp), %rdi
callq 0x3570
addq $0x10, %rsp
popq %rbp
retq
nop
// File: justinjo[P]Pacman/game.cpp
// Function: Game::print_board()
void Game::print_board()
{
        for (int r=-1; r<=ROWS; r++){
                for (int c=-1; c<=COLS; c++){
                        if ((r==-1||r==ROWS)||(c==-1||c==COLS)){
                                cout << border(r,c);
                        } else {
                                cout << board[r][c];
                        }
                }
                cout << endl;
        }
        cout << "Score: " << p.get_score() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x15, -0xc(%rbp)
jg 0x362b
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
cmpl $0x3d, -0x10(%rbp)
jg 0x360a
cmpl $-0x1, -0xc(%rbp)
je 0x35ba
cmpl $0x15, -0xc(%rbp)
je 0x35ba
cmpl $-0x1, -0x10(%rbp)
je 0x35ba
cmpl $0x3d, -0x10(%rbp)
jne 0x35da
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3680
movq 0x49f8(%rip), %rdi      # 0x7fc8
movsbl %al, %esi
callq 0x2190
jmp 0x35fd
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3d, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq 0x49d4(%rip), %rdi      # 0x7fc8
movsbl (%rax,%rcx), %esi
callq 0x2190
jmp 0x35ff
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x359c
movq 0x49b7(%rip), %rdi      # 0x7fc8
movq 0x4998(%rip), %rsi      # 0x7fb0
callq 0x2130
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x358b
movq 0x4996(%rip), %rdi      # 0x7fc8
leaq 0x1abf(%rip), %rsi      # 0x50f8
callq 0x2120
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2ba0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2270
movq %rax, %rdi
movq 0x4949(%rip), %rsi      # 0x7fb0
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::border(int, int)
char Game::border(int row, int col)
{
        if (row == -1 || row == ROWS){
                if (col == -1 || col == COLS){
                        return BORD_CORN;
                } else {
                        return BORD_TOP;
                }
        } else {
                return BORD_SIDE;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x369a
cmpl $0x15, -0x14(%rbp)
jne 0x36b2
cmpl $-0x1, -0x18(%rbp)
je 0x36a6
cmpl $0x3d, -0x18(%rbp)
jne 0x36ac
movb $0x2b, -0x1(%rbp)
jmp 0x36b6
movb $0x2d, -0x1(%rbp)
jmp 0x36b6
movb $0x7c, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::init_dots()
void Game::init_dots()
{
        set_boulders(); // to avoid boulders in each level
        for (int i=0; i<NUM_DOTS; i++){
                dots[i].set_random_location(board);
                dots[i].set_eaten(false);
                dots[i].place_on_board(board); // to ensure no dots overlap
        }
        clear_board();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x36c0
movl $0x0, -0xc(%rbp)
cmpl $0x32, -0xc(%rbp)
jge 0x37aa
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x554, %rdi            # imm = 0x554
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x4450
movq -0x18(%rbp), %rdi
addq $0x554, %rdi            # imm = 0x554
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x4560
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x554, %rdi            # imm = 0x554
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x44f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3740
movq -0x18(%rbp), %rdi
callq 0x3510
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: justinjo[P]Pacman/game.cpp
// Function: Game::eat_dot(int, int)
void Game::eat_dot(int r, int c)
{
        for (int i=0; i<DOTS_PER_LEVEL*level; i++)
                if (dots[i].is_at(r,c))
                        dots[i].was_eaten();
        p.add_to_score(DOT_REWARD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
imull $0x5, 0x504(%rcx), %ecx
cmpl %ecx, %eax
jge 0x38a2
movq -0x20(%rbp), %rdi
addq $0x554, %rdi            # imm = 0x554
movslq -0x14(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4520
testb $0x1, %al
jne 0x387a
jmp 0x3895
movq -0x20(%rbp), %rdi
addq $0x554, %rdi            # imm = 0x554
movslq -0x14(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x4580
jmp 0x3897
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3841
movq -0x20(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
movl $0x1, %esi
callq 0x2b80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)