LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/core.cpp
// Function: restore(TodoList*&)
void restore(TodoList *&list)
{
    if (!backup_)
        return;
    delete list;
    list = new TodoList(backup_);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x9c26(%rip)      # 0x10570
je 0x698b
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x695f
movq %r14, %rdi
callq 0x8dfe
movl $0x28, %esi
movq %r14, %rdi
callq 0x32b0
movl $0x28, %edi
callq 0x32a0
movq %rax, %r14
movq 0x9bf0(%rip), %rsi      # 0x10570
movq %rax, %rdi
callq 0x8d74
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/draw.cpp
// Function: drawTitle(TodoList*)
void drawTitle(TodoList* list)
{
    titleWin->clear();
    titleWin->inverse();
    titleWin->color(TITLE_COLOR_PAIR);
    titleWin->print(buildTitle(list), 0, 0);
    titleWin->colorOff(TITLE_COLOR_PAIR);
    titleWin->inverseOff();
    titleWin->color(BORDER_COLOR_PAIR, true);
    titleWin->draw();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x9745(%rip), %rdi      # 0x10660
callq 0xb56e
movq 0x9739(%rip), %rdi      # 0x10660
xorl %esi, %esi
callq 0xb6cc
movq 0x972b(%rip), %rdi      # 0x10660
movl $0x1, %esi
xorl %edx, %edx
callq 0xb71e
movq 0x9718(%rip), %r14      # 0x10660
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x82c4
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xb70c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x96d9(%rip), %rdi      # 0x10660
movl $0x1, %esi
xorl %edx, %edx
callq 0xb732
movq 0x96c6(%rip), %rdi      # 0x10660
xorl %esi, %esi
callq 0xb6de
movq 0x96b8(%rip), %rdi      # 0x10660
movl $0x4, %esi
movl $0x1, %edx
callq 0xb71e
movq 0x96a2(%rip), %rdi      # 0x10660
callq 0xb584
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6feb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/draw.cpp
// Function: Draw::mouse(MEVENT, TodoList*, unsigned int&, bool)
void Draw::mouse(MEVENT event, TodoList *list,
                 unsigned &selected, bool button)
{
    int x = event.x;
    int y = event.y;
    if (taskWin->mouse(x, y)){
        unsigned pos = listOff + y - 1;
        if (pos < list->size()){
            if (!button){
                selected = pos;
            } else{
                list->at(pos).toggleComplete();
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x34(%rsp), %eax
movl 0x38(%rsp), %ecx
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rsp, %rdx
movl %ecx, (%rdx)
movq 0x8486(%rip), %rdi      # 0x10668
callq 0xb746
testb %al, %al
je 0x8225
movl 0x84af(%rip), %eax      # 0x106a0
movl (%rsp), %ecx
leal (%rax,%rcx), %r15d
decl %r15d
movq %rbx, %rdi
callq 0x94b2
cmpl %eax, %r15d
jae 0x8225
testb %bpl, %bpl
je 0x8222
movq %rbx, %rdi
movl %r15d, %esi
callq 0x94c8
movq %rax, %rdi
callq 0x8804
jmp 0x8225
movl %r15d, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/draw.cpp
// Function: drawDivider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void drawDivider(string div, int ypos)
{
    if (showNumbers) {
        for (unsigned i = 0; i < 3; i++) {
            div = "=" + div;
        }
    }
    while ((int) div.size() < width - 3){
        div += division;
    }
    taskWin->print(div, 1, ypos);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x3, %ebp
leaq 0x38(%rsp), %r13
leaq 0x3eaf(%rip), %r15      # 0xc488
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x69ab
movq %r14, %rdi
movq %r12, %rsi
callq 0x3360
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x860e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
decl %ebp
jne 0x85de
jmp 0x862a
movq 0x7fe5(%rip), %rsi      # 0x10600
movq 0x7fe6(%rip), %rdx      # 0x10608
movq %r14, %rdi
callq 0x3100
movq 0x8(%r14), %rdx
movl 0x8054(%rip), %eax      # 0x10688
addl $-0x3, %eax
cmpl %edx, %eax
jg 0x8614
movq 0x8026(%rip), %r15      # 0x10668
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5bf4
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xb70c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8688
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x86b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/draw.cpp
// Function: Draw::stop()
void Draw::stop()
{
    delete titleWin;
    delete taskWin;
    delete controlWin;
    delete inputWin;

    endwin();

    curs_set(1);
}

// Assembly:
pushq %rbx
movq 0x7f9f(%rip), %rbx      # 0x10660
testq %rbx, %rbx
je 0x86ce
movq %rbx, %rdi
callq 0xb52e
movl $0x40, %esi
movq %rbx, %rdi
callq 0x32b0
movq 0x7f86(%rip), %rbx      # 0x10668
testq %rbx, %rbx
je 0x86ef
movq %rbx, %rdi
callq 0xb52e
movl $0x40, %esi
movq %rbx, %rdi
callq 0x32b0
movq 0x7f6d(%rip), %rbx      # 0x10670
testq %rbx, %rbx
je 0x8710
movq %rbx, %rdi
callq 0xb52e
movl $0x40, %esi
movq %rbx, %rdi
callq 0x32b0
movq 0x7f54(%rip), %rbx      # 0x10678
testq %rbx, %rbx
je 0x8731
movq %rbx, %rdi
callq 0xb52e
movl $0x40, %esi
movq %rbx, %rdi
callq 0x32b0
callq 0x3340
movl $0x1, %edi
popq %rbx
jmp 0x3240
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/task.cpp
// Function: Task::task[abi:cxx11]()
string Task::task()
{
    string value = "";
    
    if (complete){
        value += STRING_COMPLETE;
    } else{
        value += STRING_NOT_COMPLETE;
    }
    
    value += " " + name;
    
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x3c69(%rip), %rdx      # 0xc490
movq %rdx, %rsi
callq 0x5c8a
leaq 0x7ed2(%rip), %rax      # 0x10708
leaq 0x7eab(%rip), %rcx      # 0x106e8
cmpb $0x0, 0x20(%r14)
cmovneq %rax, %rcx
movq (%rcx), %rsi
leaq 0x7ec0(%rip), %rax      # 0x10710
leaq 0x7e99(%rip), %rcx      # 0x106f0
cmovneq %rax, %rcx
movq (%rcx), %rdx
movq %rbx, %rdi
callq 0x3100
leaq 0x3c6c(%rip), %rsi      # 0xc4d9
movq %rsp, %rdi
movq %r14, %rdx
callq 0x69ab
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3100
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x88a4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x88d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x88d6
jmp 0x88d3
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x88e9
movq (%r15), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3500
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x3b7e(%rip), %rdx      # 0xc490
movq %rdx, %rsi
callq 0x5c8a
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3100
leaq 0x3cd9(%rip), %rsi      # 0xc609
movq %rbx, %rdi
callq 0x3560
movzbl 0x20(%r14), %ebp
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %rdi
movl $0x1, %esi
movl $0x2d, %edx
callq 0x3330
movq (%rsp), %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x874e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3100
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8990
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x89c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x89c0
jmp 0x89bd
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x89d3
movq (%r15), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3500
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rsi), %rax
movl $0x1, %edx
cmpq $0x1, %rax
je 0x8a6c
movl $0x1, %ebx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %rax, %rdx
movq %r15, %r13
notq %r13
addq %r13, %rdx
movl $0x1, %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x32c0
movq %r12, %rdi
leaq 0x3bd6(%rip), %rsi      # 0xc609
callq 0x30f0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8a56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
testl %ebp, %ebp
je 0x8a7f
movl %ebx, %r15d
movq 0x8(%r14), %rdx
leaq -0x1(%rdx), %rax
incl %ebx
cmpq %r15, %rax
ja 0x8a10
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
jmp 0x8b21
movq 0x8(%r14), %rdx
subq %r15, %rdx
leaq 0x8(%rsp), %r12
movl $0x1, %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x3564(%rip), %rsi      # 0xc006
movq %r12, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8ac7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
testl %ebp, %ebp
movq (%rsp), %rbx
jne 0x8ad4
movb $0x1, 0x20(%r14)
addq 0x8(%r14), %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x32c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x3360
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8b13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5bf4
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
callq 0x445c
testb %al, %al
jne 0x8cd7
callq 0x6ab4
callq 0x5f2c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5f69
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c67
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rsp, %rbx
movq %r14, (%rbx)
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
movq 0x7348(%rip), %r15      # 0xffc8
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x6ee4
movq (%r15), %rdi
callq 0x3140
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6006
testb %al, %al
je 0x8c80
callq 0x86b9
callq 0x5f46
movq (%rsp), %rdi
callq 0x8e4a
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x8cca
movq %rbx, %rdi
callq 0x8dfe
movl $0x28, %esi
movq %rbx, %rdi
callq 0x32b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d01
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x9030
movq (%r14), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x3180
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x8e92
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9186
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x3570
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x8ecf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x8efc
movq 0x70ea(%rip), %rdi      # 0xffd0
leaq 0x3767(%rip), %rsi      # 0xc654
movl $0x1c, %edx
callq 0x3310
jmp 0x8f99
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
je 0x8f8f
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x31bb(%rip), %r12      # 0xc0e2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x94c8
movq %r14, %rdi
movq %rax, %rsi
callq 0x88f2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3310
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8f75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
incl %ebp
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %eax # imm = 0xCCCCCCCD
cmpl %eax, %ebp
jb 0x8f27
leaq 0x28(%rsp), %rdi
callq 0x33b0
movq 0x7020(%rip), %rax      # 0xffc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x3260
leaq 0x120(%rsp), %rdi
callq 0x3120
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8fff
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9028
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x9028
movq %rax, %rbx
jmp 0x901e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x901e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x28(%rsp), %rdi
callq 0x33d0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::remove(unsigned int)
void TodoList::remove(unsigned position)
{
    if (taskList->size() > position){
        taskList->erase(taskList->begin() + position);
    }
    if (autoSave){
        save();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
movl %esi, %ecx
cmpq %rcx, %rdx
jbe 0x9d59
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rsi
callq 0xa612
movq %rbx, %rdi
popq %rbx
jmp 0x8e4a
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq (%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %rdx
subq %r12, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
imulq %rbp, %rdx
leal -0x1(%rdx), %eax
cmpl %esi, %eax
jbe 0x9e7c
movl %eax, 0xc(%rsp)
movl %ebx, %esi
cmpq %rsi, %rdx
jbe 0x9ea1
movq %rdi, %r14
leaq (%rsi,%rsi,4), %r13
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12,%r13,8), %rsi
movq 0x8(%r12,%r13,8), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x5bf4
movb 0x20(%r12,%r13,8), %al
movb %al, 0x20(%r15)
movq (%r14), %rcx
leal 0x1(%rbx), %r15d
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
cmpq %r15, %rdx
jbe 0x9e90
leaq (%r15,%r15,4), %rbp
leaq (%rax,%rbp,8), %r12
leaq (%rax,%r13,8), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x31b0
movb 0x20(%r12), %al
movb %al, 0x20(%r13)
movq (%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0x9e90
leaq (%rax,%rbp,8), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x31b0
movb 0x30(%rsp), %al
movb %al, 0x20(%r14)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9e78
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movl 0xc(%rsp), %eax
cmpl %ebx, %eax
seta %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2551(%rip), %rdi      # 0xc3e8
movq %r15, %rsi
xorl %eax, %eax
callq 0x3410
leaq 0x2540(%rip), %rdi      # 0xc3e8
xorl %eax, %eax
callq 0x3410
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9ece
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
imulq %rbp, %rdx
testl %edx, %edx
je 0xa006
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq %r14, %rdx
jbe 0xa015
addq %r15, %rdi
callq 0x8b68
testb %al, %al
je 0x9f62
movl %r13d, %eax
cmpq %rax, %r14
je 0x9fdb
movq (%rbx), %rcx
movq (%rcx), %r12
leaq (%rax,%rax,4), %rcx
leaq (%r12,%rcx,8), %r13
addq %r15, %r12
shlq $0x3, %rax
leaq (%rax,%rax,4), %rax
movq %r15, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
bsrq %rcx, %rdx
jmp 0x9fa5
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r12
movq %r12, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
decl %ecx
cmpq %rcx, %r14
jne 0x9fdf
movl %r13d, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %r12, %r13
je 0x9fdb
movq %r12, %rax
subq %r13, %rax
sarq $0x3, %rax
imulq %rbp, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r12, %rsi
leaq -0x13c5(%rip), %rbp     # 0x8bf6
movq %rbp, %rcx
callq 0xa6aa
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
callq 0xa79d
leal 0x1(%r14), %r13d
incq %r14
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
movl %edx, %eax
addq $0x28, %r15
cmpq %rax, %r14
jb 0x9f14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23cc(%rip), %rdi      # 0xc3e8
movq %r14, %rsi
xorl %eax, %eax
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3550
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x3190
movq 0x8(%rbx), %r14
leaq 0x20(%rbx), %rdx
leaq 0xec0(%rip), %rsi       # 0xc47c
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x69ab
leaq 0xa3a(%rip), %rsi       # 0xc00a
movq %r15, %rdi
callq 0x3560
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rcx
movq %rax, %rdx
addq $0x10, %rdx
cmpq %rdx, %rcx
je 0xb5fe
movq %rcx, (%rsp)
movq (%rdx), %rsi
movq %rsi, 0x10(%rsp)
jmp 0xb608
movups (%rdx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rcx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rdx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x30c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb644
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb65f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x3380
movq 0x8(%rbx), %rdi
callq 0x3300
movq (%rbx), %rdi
callq 0x3300
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb6a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0xb6a8
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb6c3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x3820(%rip), %rsi      # 0x6034
callq 0x2090
testl %eax, %eax
je 0x2853
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2d, (%rcx)
movq 0x8(%rbx), %rsi
sete %dl
movb $0x1, %al
cmpq %rdx, %rsi
jbe 0x2855
decq %rsi
movsbl (%rcx,%rdx), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
setb %al
jae 0x2855
leaq 0x1(%rdx), %rdi
cmpq %rdx, %rsi
movq %rdi, %rdx
jne 0x2836
jmp 0x2855
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x2a0c
movq %rsi, %r14
movq (%rsi), %rbp
leaq 0x8(%rsp), %r12
movq %rbp, %r15
movsbl (%r15), %edi
callq 0x2050
testl %eax, %eax
je 0x2955
incq %r15
jmp 0x29e1
movq 0x10(%rsp), %rdx
movq %r12, %rdi
xorl %esi, %esi
leaq 0x3803(%rip), %rcx      # 0x6169
xorl %r8d, %r8d
callq 0x2240
movsbl (%r15), %r13d
movl %r13d, %edi
callq 0x2250
testl %eax, %eax
je 0x299c
movsbl (%r15), %ebp
movl %ebp, %edi
callq 0x2250
testl %eax, %eax
je 0x29cf
incq %r15
movq %r12, %rdi
movl %ebp, %esi
callq 0x2170
jmp 0x297e
leal -0x30(%r13), %eax
cmpl $0x9, %eax
ja 0x29c1
movsbl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x29cf
incq %r15
movsbl %al, %esi
movq %r12, %rdi
callq 0x2170
jmp 0x29a5
movq %r12, %rdi
movl %r13d, %esi
callq 0x2170
incq %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a64
movq (%r14), %rbp
movq 0x8(%r14), %r13
movq %rbp, %rax
addq %r13, %rax
cmpq %rax, %r15
jne 0x2940
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a0c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a24
jmp 0x2a24
jmp 0x2a24
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2aa2
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::insert(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool insert (const expression& expr) {
            step s;
            int id = to_int(expr[0]);

            if (expr.size() == 1) {
                if (program.count(id)) 
                    program.erase(id);
                return true;
            }
            
            s.expr = expr;
            if (!command_id.count(s.expr[1]))
                return false;
      
            s.type = command_id[s.expr[1]];
            s.expr.erase(s.expr.begin());
            s.expr.erase(s.expr.begin());

            if (!check(s)) return false;
      
            program[id] = s;
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rsi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movb (%rcx), %dl
xorl %r8d, %r8d
cmpb $0x2d, %dl
sete %r8b
xorl %r9d, %r9d
cmpq %r8, %rdi
jbe 0x31b6
xorl %r9d, %r9d
leal (%r9,%r9,4), %r9d
movsbl (%rcx,%r8), %r10d
leal (%r10,%r9,2), %r9d
addl $-0x30, %r9d
incq %r8
cmpq %r8, %rdi
jne 0x319d
leaq 0x10(%rsp), %rbx
movl %r9d, %ecx
negl %ecx
cmpb $0x2d, %dl
cmovnel %r9d, %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rsi), %rdx
subq %rax, %rdx
cmpq $0x20, %rdx
jne 0x3239
movq 0x48(%r14), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0x32fc
leaq 0x38(%r14), %r15
addq $0x40, %r14
movq %r14, %rdx
xorl %esi, %esi
cmpl %ecx, 0x20(%rax)
setl %sil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x31f3
cmpq %r14, %rdx
je 0x32fc
cmpl 0x20(%rdx), %ecx
jl 0x32fc
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x4e88
movq %r15, %rdi
movq %rax, %rsi
callq 0x4f06
jmp 0x32fc
movq %rbx, %rdi
callq 0x4ad8
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x5f67(%rip), %rdi      # 0x91b8
callq 0x50ac
leaq 0x5f63(%rip), %rcx      # 0x91c0
cmpq %rcx, %rax
je 0x32fa
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x5f42(%rip), %rdi      # 0x91b8
callq 0x4c6e
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x548c
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x548c
movl 0x8(%rsp), %eax
leaq 0x30(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4866
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x4cea
movl %eax, %ebp
movq %r15, %rdi
callq 0x2aa2
testb %bpl, %bpl
je 0x32fa
addq $0x38, %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4e22
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movb $0x1, %bpl
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4ad8
jmp 0x32fc
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2aa2
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x2aa2
jmp 0x3325
jmp 0x3322
jmp 0x3322
movq %rax, %r14
movq %rbx, %rdi
callq 0x2aa2
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::compare(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
bool compare(const expr_iter& begin,
                     const expr_iter& end) {
            for (expr_iter ptr = begin + 1; ptr != end; ++ptr) {
                if (*ptr == ">") return eval(begin, ptr) >  eval(ptr + 1, end);
                if (*ptr == "<") return eval(begin, ptr) <  eval(ptr + 1, end);
                if (*ptr == "=") return eval(begin, ptr) == eval(ptr + 1, end);
            }
            return 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rsi), %rbx
leaq 0x292e(%rip), %r13      # 0x6103
leaq 0x2929(%rip), %rbp      # 0x6105
leaq 0x20(%rbx), %r15
movq (%r14), %r12
cmpq %r12, %r15
je 0x3863
movq %r15, %rdi
movq %r13, %rsi
callq 0x2090
testl %eax, %eax
je 0x3871
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2090
testl %eax, %eax
je 0x38b7
movq %r15, %rdi
leaq 0x28f3(%rip), %rsi      # 0x6107
callq 0x2090
movq %r15, %rbx
testl %eax, %eax
jne 0x37dc
leaq 0x18(%rsp), %rbx
movq %r15, (%rbx)
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x394a
movl %eax, %ebp
movq (%rbx), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
movq %r14, %rdx
callq 0x394a
cmpl %eax, %ebp
sete %cl
jmp 0x38fb
addq $0x20, %rbx
movq %rbx, 0x18(%rsp)
jmp 0x38fb
addq $0x20, %rbx
leaq 0x18(%rsp), %r13
movq %rbx, (%r13)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x394a
movl %eax, %ebp
movq (%r13), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x394a
cmpl %eax, %ebp
setg %cl
jmp 0x38fb
addq $0x20, %rbx
leaq 0x18(%rsp), %r13
movq %rbx, (%r13)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x394a
movl %eax, %ebp
movq (%r13), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x394a
cmpl %eax, %ebp
setl %cl
cmpq %r12, %r15
setne %al
andb %cl, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::eval(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
int eval(const expr_iter& begin,
                 const expr_iter& end) {
            std::vector<expr_iter> match(end - begin), stack;
            for (expr_iter ptr = begin; ptr != end; ptr++) {
                if (*ptr == "(") stack.emplace_back(ptr);
                else if (*ptr == ")") {
                    match[stack.back() - begin] = ptr;
                    stack.pop_back();
                }
            }
            return eval(begin, end, begin, match);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x40(%rsp)
movq (%rdx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x40ac
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq (%rbx), %rdi
movq %rdi, 0x8(%rsp)
cmpq %rdi, (%r14)
je 0x3a14
leaq 0x2767(%rip), %r12      # 0x6109
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x2787(%rip), %r15      # 0x613a
movq %r12, %rsi
callq 0x2090
testl %eax, %eax
je 0x39f6
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2090
testl %eax, %eax
jne 0x3a01
movq 0x18(%rsp), %rax
movq -0x8(%rax), %rax
subq (%rbx), %rax
movq 0x28(%rsp), %rcx
sarq $0x2, %rax
movq 0x8(%rsp), %rdx
movq %rdx, (%rcx,%rax)
addq $-0x8, 0x18(%rsp)
jmp 0x3a01
movq %r13, %rdi
movq %rbp, %rsi
callq 0x411a
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
cmpq %rdi, (%r14)
jne 0x39b3
leaq 0x28(%rsp), %r8
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4152
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3a45
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3a5c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a6f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3a89
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa0
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x54f4(%rip), %r15      # 0x8fd0
leaq 0x2673(%rip), %r12      # 0x6156
movq 0x54f6(%rip), %r13      # 0x8fe0
leaq 0x18(%rsp), %rbp
leaq 0x2664(%rip), %rbx      # 0x615a
movl $0x3, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22c0
movq %rbp, %rdi
callq 0x2809
testb %al, %al
jne 0x3b47
movl $0xf, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21e0
jmp 0x3af6
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb (%rax), %bl
xorl %edx, %edx
cmpb $0x2d, %bl
sete %dl
xorl %r15d, %r15d
cmpq %rdx, %rcx
jbe 0x3b7e
xorl %r15d, %r15d
leal (%r15,%r15,4), %esi
movsbl (%rax,%rdx), %edi
leal (%rdi,%rsi,2), %r15d
addl $-0x30, %r15d
incq %rdx
cmpq %rdx, %rcx
jne 0x3b66
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3be6
movl %r15d, %ecx
negl %ecx
cmpb $0x2d, %bl
cmovnel %r15d, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bb2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bc3
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bdd
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2809
testb %al, %al
je 0x45be
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movb (%rax), %cl
xorl %esi, %esi
cmpb $0x2d, %cl
sete %sil
xorl %edi, %edi
cmpq %rsi, %rdx
jbe 0x45b2
xorl %edi, %edi
leal (%rdi,%rdi,4), %edi
movsbl (%rax,%rsi), %r8d
leal (%r8,%rdi,2), %edi
addl $-0x30, %edi
incq %rsi
cmpq %rsi, %rdx
jne 0x459b
movl %edi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edi, %eax
jmp 0x45db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x482c
testq %rax, %rax
je 0x45e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3be6
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x20d0
leaq 0x479c(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rax
shlq $0x5, %rax
leaq 0x47fe(%rip), %rcx      # 0x91f0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
callq 0x21e0
movq 0x8(%r14), %r12
movq 0x10(%r14), %rbp
cmpq %rbp, %r12
je 0x4a7c
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
movq %r13, 0x8(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3e92
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x4a1c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4acf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::check(basic::basic_interpreter::step)
bool check(step s) {
            switch (s.type) {
            case 1:
                REPORT(s.expr.size() < 3);
                REPORT(!is_var(s.expr[0]));
                REPORT(s.expr[1] != "=");
                REPORT(!check_expr(s.expr.begin() + 2, s.expr.end()));
                break;
            case 2:
                //REPORT(s.expr.size() < 1);
                REPORT(!check_expr(s.expr.begin(), s.expr.end()));
                break;
            case 3:
                REPORT(s.expr.size() != 1);
                REPORT(!check_expr(s.expr.begin(), s.expr.end()));
                break;
            case 4:
                REPORT(s.expr.size() != 0);
                break;
            case 5:
                REPORT(s.expr.size() != 1);
                REPORT(!is_digit(s.expr[0]));
                break;
            case 6:
                REPORT(s.expr.size() < 5);
                REPORT(!is_digit(*(s.expr.end() - 1)));
                REPORT(*(s.expr.end() - 2) != "THEN");
                REPORT(!check_expr(s.expr.begin(), s.expr.end() - 2));
            }

            return true;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl (%rsi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x4dc6
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1311(%rip), %rcx      # 0x601c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cmpq $0x41, %rax
jb 0x4e02
callq 0x2857
testb %al, %al
je 0x4e02
movq 0x8(%r14), %rdi
addq $0x20, %rdi
leaq 0x13c2(%rip), %rsi      # 0x6107
callq 0x2090
testl %eax, %eax
jne 0x4e02
movq 0x8(%r14), %rax
addq $0x40, %rax
jmp 0x4da6
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x4e02
callq 0x2809
jmp 0x4dc2
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq %rax, %rdx
subq %rcx, %rdx
cmpq $0x20, %rdx
jne 0x4e02
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
jmp 0x4db2
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
jne 0x4e02
jmp 0x4dc6
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x10(%r14), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0x5508
testb %al, %al
je 0x4e02
movb $0x1, %al
jmp 0x4e04
movq 0x10(%r14), %rdi
movq %rdi, %rax
subq 0x8(%r14), %rax
cmpq $0x81, %rax
jb 0x4e02
addq $-0x20, %rdi
callq 0x2809
testb %al, %al
je 0x4e02
movq 0x10(%r14), %rdi
addq $-0x40, %rdi
leaq 0x1371(%rip), %rsi      # 0x616a
callq 0x2090
testl %eax, %eax
je 0x4e0c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x10(%r14), %rax
addq $-0x40, %rax
jmp 0x4db2
// File: /workspace/github_cpp_makefile_star2_O3/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::check_expr(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
bool check_expr(const expr_iter& begin,
                        const expr_iter& end) {
            int cnt = 0;
            for (auto ptr = begin; ptr != end; ptr++) {
                if (*ptr == "(") {
                    ++cnt;
                    if (ptr + 1 == end) return false;
                    if (*(ptr + 1) == ")") return false;
                }
                if (*ptr == ")") if (--cnt < 0) return false;
                if (is_element(*ptr) && ptr + 1 != end && *(ptr + 1) != ")") {
                    if (ptr + 2 == end || (!is_element(*(ptr + 2)) && *(ptr + 2) != "("))
                        return false;
                }
            }
      
            return cnt == 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r14
cmpq %r14, (%rdx)
je 0x55e6
movq %rdx, %rbx
xorl %ebp, %ebp
leaq 0xbde(%rip), %r15       # 0x6109
leaq 0xc08(%rip), %r12       # 0x613a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2090
testl %eax, %eax
jne 0x5560
incl %ebp
leaq 0x20(%r14), %rdi
cmpq (%rbx), %rdi
je 0x55ea
movq %r12, %rsi
callq 0x2090
testl %eax, %eax
je 0x55ea
movq %r14, %rdi
movq %r12, %rsi
callq 0x2090
testl %eax, %eax
jne 0x5578
leal -0x1(%rbp), %eax
testl %ebp, %ebp
jle 0x55ee
movl %eax, %ebp
movq %r14, %rdi
callq 0x2857
testb %al, %al
jne 0x5590
movq %r14, %rdi
callq 0x2809
testb %al, %al
je 0x55d5
leaq 0x20(%r14), %rdi
cmpq (%rbx), %rdi
je 0x55d5
movq %r12, %rsi
callq 0x2090
testl %eax, %eax
je 0x55d5
leaq 0x40(%r14), %r13
cmpq (%rbx), %r13
je 0x55ea
movq %r13, %rdi
callq 0x2857
testb %al, %al
jne 0x55d5
movq %r13, %rdi
callq 0x2809
testb %al, %al
jne 0x55d5
movq %r13, %rdi
movq %r15, %rsi
callq 0x2090
testl %eax, %eax
jne 0x55ea
addq $0x20, %r14
cmpq (%rbx), %r14
jne 0x5532
movb $0x1, %cl
jmp 0x55f2
movb $0x1, %al
jmp 0x55f9
xorl %ecx, %ecx
jmp 0x55f2
xorl %ecx, %ecx
movl %eax, %ebp
testl %ebp, %ebp
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/pacman.cpp
// Function: Pacman::move(char (*) [61], char)
bool Pacman::move(char board[ROWS][COLS], char command)
{
        bool ate_dot = false;
        rotate_head(command);
        num_moves++;
        if (!boulder_ahead(board, command)){
                board[row][col] = SPACE;
                if (command == CMD_UP){         // move, wrap if needed
                        if (row == 0) {row = ROWS-1;} else {row--;}
                } else if (command == CMD_DWN){
                        if (row == ROWS-1) {row = 0;} else {row++;}
                } else if (command == CMD_RGT){
                        if (col == COLS-1) {col = 0;} else {col++;}
                } else if (command == CMD_LFT){
                        if (col == 0) {col = COLS-1;} else {col--;}
                }
        }
        if (board[row][col] == GHOST)
                die();
        if (board[row][col] == DOT){
                ate_dot = true;
                dots_eaten++;
        }
        return ate_dot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x72, %edx
jg 0x24df
cmpl $0x61, %edx
je 0x24ed
cmpl $0x64, %edx
jne 0x24f6
movb $0x3c, %al
jmp 0x24f3
cmpl $0x77, %edx
je 0x24f1
cmpl $0x73, %edx
jne 0x24f6
movb $0x5e, %al
jmp 0x24f3
movb $0x3e, %al
jmp 0x24f3
movb $0x76, %al
movb %al, 0x1(%rbx)
incl 0xc(%rbx)
movsbl %dl, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x260e
testb %al, %al
je 0x2546
movslq 0x4(%rbx), %rax
movslq 0x8(%rbx), %rcx
imulq $0x3d, %rax, %rax
addq %rax, %r14
movb (%rcx,%r14), %al
cmpb $0x6d, %al
jne 0x252f
addq %rcx, %r14
movb $0x0, (%rbx)
movb (%r14), %al
cmpb $0x6f, %al
jne 0x2536
incl 0x14(%rbx)
cmpb $0x6f, %al
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x4(%rbx), %rax
movslq 0x8(%rbx), %rcx
imulq $0x3d, %rax, %rax
addq %r14, %rax
movb $0x20, (%rcx,%rax)
cmpl $0x72, %r15d
jg 0x257c
cmpl $0x61, %r15d
je 0x2593
cmpl $0x64, %r15d
jne 0x250f
movl 0x8(%rbx), %eax
cmpl $0x3c, %eax
jne 0x25b2
movl $0x0, 0x8(%rbx)
jmp 0x250f
cmpl $0x73, %r15d
je 0x259e
cmpl $0x77, %r15d
jne 0x250f
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x25c6
decl %eax
jmp 0x25be
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x25d2
decl %eax
jmp 0x25b4
movl 0x4(%rbx), %eax
cmpl $0x14, %eax
jne 0x25bc
movl $0x0, 0x4(%rbx)
jmp 0x250f
incl %eax
movl %eax, 0x8(%rbx)
jmp 0x250f
incl %eax
movl %eax, 0x4(%rbx)
jmp 0x250f
movl $0x14, 0x4(%rbx)
jmp 0x250f
movl $0x3c, 0x8(%rbx)
jmp 0x250f