LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/args.cpp
// Function: printUsage()
void printUsage()
{
    cout << ANSI_BLUE << "todo version " << vn << ANSI_RESET << "\n";
    cout << "\n";
    cout << ANSI_BLUE << "syntax" << ANSI_RESET << "\n";
    cout << ANSI_WHITE << "todo [list name] [arguments]";
    cout << ANSI_RESET << "\n";
    cout << "If no name is provided, '" << DEFAULT_NAME;
    cout << "' will be used.\n"; 
    cout << "\n";
    cout << ANSI_BLUE << "arguments" << ANSI_RESET << "\n";
    cout << "-h, -help, --help   -> prints usage and exits\n";
    cout << "-version, --version -> prints version information and exits\n";
    cout << "\n";
    cout << "-d, --delete    -> delete the to-do list\n";
    cout << "-l, --list      -> list all to-do lists and exit\n";
    cout << "-nc, --no-color -> disable colored output\n";
    cout << "-p, --print     -> print the to-do list to the console";
    cout << " and exit\n";
    cout << "-r, --rename    -> rename the to-do list\n";
    cout << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xa9a8(%rip), %rbx      # 0xefd0
leaq 0xae31(%rip), %r15      # 0xf460
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3270
leaq 0x5ef7(%rip), %rsi      # 0xa538
movq %rax, %rdi
callq 0x3290
leaq 0xacb0(%rip), %rsi      # 0xf300
movq %rax, %rdi
callq 0x3270
leaq 0xada1(%rip), %r12      # 0xf400
movq %rax, %rdi
movq %r12, %rsi
callq 0x3270
leaq 0x5a78(%rip), %r14      # 0xa0e9
movq %rax, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3270
leaq 0x5a8d(%rip), %rsi      # 0xa126
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movq %r12, %rsi
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x3290
leaq 0xadc2(%rip), %rsi      # 0xf480
movq %rbx, %rdi
callq 0x3270
leaq 0x5a60(%rip), %rsi      # 0xa12d
movq %rax, %rdi
callq 0x3290
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x3290
leaq 0x5a58(%rip), %rsi      # 0xa14a
movq %rbx, %rdi
callq 0x3290
leaq 0xac1f(%rip), %rsi      # 0xf320
movq %rax, %rdi
callq 0x3270
leaq 0x5a54(%rip), %rsi      # 0xa164
movq %rbx, %rdi
callq 0x3290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3270
leaq 0x5a40(%rip), %rsi      # 0xa175
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movq %r12, %rsi
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x3290
leaq 0x5a25(%rip), %rsi      # 0xa17f
movq %rbx, %rdi
callq 0x3290
leaq 0x5a45(%rip), %rsi      # 0xa1ae
movq %rbx, %rdi
callq 0x3290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
leaq 0x5a68(%rip), %rsi      # 0xa1eb
movq %rbx, %rdi
callq 0x3290
leaq 0x5a83(%rip), %rsi      # 0xa215
movq %rbx, %rdi
callq 0x3290
leaq 0x5aa6(%rip), %rsi      # 0xa247
movq %rbx, %rdi
callq 0x3290
leaq 0x5ac2(%rip), %rsi      # 0xa272
movq %rbx, %rdi
callq 0x3290
leaq 0x5a7d(%rip), %rsi      # 0xa23c
movq %rbx, %rdi
callq 0x3290
leaq 0x5adb(%rip), %rsi      # 0xa2a9
movq %rbx, %rdi
callq 0x3290
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/args.cpp
// Function: removeList()
void removeList()
{
    TodoList *list = Core::list(name());
    if (!list->exists()){
        cout << ANSI_RED << "Todo List '" << list->name;
        cout << "' does not exist!\n" << ANSI_RESET;
        return;
    }

    string choice;
    cout << "Remove list? [Y/n] > ";
    cin >> choice;
    if (choice != "Y"){
        cout << "Not removing.\n";
        return;
    }

    if (remove(list->getPath().c_str()) != 0){
        cout << ANSI_RED << "Failed to remove list!\n" << ANSI_RESET;
        return;
    }
    cout << "List removed.\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x4f72
movq %rbx, %rdi
callq 0x5528
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x7b5e
testb %al, %al
je 0x4b29
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xa4e1(%rip), %rdi      # 0xefd0
leaq 0x57fc(%rip), %rsi      # 0xa2f2
callq 0x3290
movq 0xa4de(%rip), %rdi      # 0xefe0
movq %rsp, %rsi
callq 0x3370
leaq 0x57f7(%rip), %rsi      # 0xa308
movq %rsp, %rdi
callq 0x51c6
testb %al, %al
je 0x4b7d
leaq 0x57e6(%rip), %rsi      # 0xa30a
jmp 0x4bdf
movq 0xa4a0(%rip), %r14      # 0xefd0
leaq 0xa8e9(%rip), %rsi      # 0xf420
movq %r14, %rdi
callq 0x3270
leaq 0x57a0(%rip), %rsi      # 0xa2e6
movq %rax, %rdi
callq 0x3290
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x55a2(%rip), %rsi      # 0xa106
movq %r14, %rdi
callq 0x3290
leaq 0xa88d(%rip), %rsi      # 0xf400
movq %rax, %rdi
callq 0x3270
jmp 0x4bf3
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x7870
leaq 0x40(%rsp), %rbx
movq (%rbx), %rdi
callq 0x3530
movl %eax, %ebp
movq %rbx, %rdi
callq 0x35a8
testl %ebp, %ebp
je 0x4bd8
movq 0xa424(%rip), %rdi      # 0xefd0
leaq 0xa86d(%rip), %rsi      # 0xf420
callq 0x3270
leaq 0x575a(%rip), %rsi      # 0xa319
movq %rax, %rdi
callq 0x3290
leaq 0xa832(%rip), %rsi      # 0xf400
movq %rax, %rdi
callq 0x3270
jmp 0x4beb
leaq 0x5752(%rip), %rsi      # 0xa331
movq 0xa3ea(%rip), %rdi      # 0xefd0
callq 0x3290
movq %rsp, %rdi
callq 0x35a8
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4c08
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x4c0e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/args.cpp
// Function: printLists()
void printLists()
{
    auto list = listFiles(TodoList::getSaveDir());

    cout << ANSI_BLUE << "to-do lists:\n" << ANSI_RESET;
    cout << "\n";

    unsigned count = 0;
    const unsigned width = getTermWidth();
    
    for (unsigned i = 0; i < list.size(); i++){
        if (count + list.at(i).length() + 10 >= width){
            count = 0;
            cout << "\n";
        }
        cout << ANSI_GREEN << list.at(i) << "  ";
        count += list.at(i).length() + 2;
    }

    cout << ANSI_RESET << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x77da
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4fb3
leaq 0x18(%rsp), %rdi
callq 0x35a8
movq 0xa37e(%rip), %rdi      # 0xefd0
leaq 0xa807(%rip), %rsi      # 0xf460
callq 0x3270
leaq 0x5486(%rip), %rsi      # 0xa0eb
movq %rax, %rdi
callq 0x3290
leaq 0xa78c(%rip), %rsi      # 0xf400
movq %rax, %rdi
callq 0x3270
movq 0xa34d(%rip), %rdi      # 0xefd0
leaq 0x545f(%rip), %rsi      # 0xa0e9
callq 0x3290
callq 0x4f8e
movl %eax, %r15d
xorl %r12d, %r12d
movq %rsp, %rbx
movq 0xa32c(%rip), %r14      # 0xefd0
xorl %ebp, %ebp
movl %ebp, %ebp
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
cmpq %rbp, %rax
jbe 0x4d41
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5186
movl %r12d, %ecx
movq 0x8(%rax), %rax
addq %rcx, %rax
addq $0xa, %rax
cmpq %r15, %rax
jb 0x4cee
xorl %r12d, %r12d
movq %r14, %rdi
leaq 0x5400(%rip), %rsi      # 0xa0e9
callq 0x3290
movq %r14, %rdi
leaq 0xa748(%rip), %rsi      # 0xf440
callq 0x3270
movq %rax, %r13
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5186
movq %r13, %rdi
movq %rax, %rsi
callq 0x3270
movq %rax, %rdi
leaq 0x57be(%rip), %rsi      # 0xa4de
callq 0x3290
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5186
movl 0x8(%rax), %eax
addl %eax, %r12d
addl $0x2, %r12d
incl %ebp
jmp 0x4ca6
movq 0xa288(%rip), %rdi      # 0xefd0
leaq 0xa6b1(%rip), %rsi      # 0xf400
callq 0x3270
leaq 0x538e(%rip), %rsi      # 0xa0e9
movq %rax, %rdi
callq 0x3290
movq %rsp, %rdi
callq 0x5164
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x35a8
jmp 0x4d98
jmp 0x4d8d
jmp 0x4d8d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5164
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/args.cpp
// Function: printTodo()
void printTodo()
{
    TodoList* list = Core::list(name());
    if (!list->exists()){
        cout << ANSI_RED << "To-do list '" << list->name;
        cout << "' does not exist!\n" << ANSI_RESET;
        return;
    }

    auto tasks = list->tasks();

    cout << ANSI_BLUE << "to-do -- " << list->name;
    cout << ANSI_RESET << "\n";
    for (unsigned i = 0; i < tasks->size(); i++){
        string taskStr = tasks->at(i).save();
        taskStr = taskStr.substr(0, taskStr.size() - 2);
        cout << i << ". " << taskStr<< "\n";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4f72
movq %rbx, %rdi
callq 0x5528
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x35a8
movq %r14, %rdi
callq 0x7b5e
testb %al, %al
je 0x4ef0
movq %r14, %rdi
callq 0x7bc2
movq %rax, %rbx
movq 0xa1de(%rip), %r15      # 0xefd0
leaq 0xa667(%rip), %rsi      # 0xf460
movq %r15, %rdi
callq 0x3270
leaq 0x5311(%rip), %rsi      # 0xa119
movq %rax, %rdi
callq 0x3290
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3270
leaq 0xa5da(%rip), %rsi      # 0xf400
movq %r15, %rdi
callq 0x3270
leaq 0x52b4(%rip), %rsi      # 0xa0e9
movq %rax, %rdi
callq 0x3290
xorl %r12d, %r12d
pushq $0x28
popq %r15
leaq 0x8(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x52ce(%rip), %r14      # 0xa123
movl %r12d, %r12d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
cmpq %r12, %rax
jbe 0x4f42
movq %rbx, %rdi
movq %r12, %rsi
callq 0x51a8
movq %r13, %rdi
movq %rax, %rsi
callq 0x7272
movq 0x10(%rsp), %rcx
addq $-0x2, %rcx
movq %rbp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x32c0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3360
movq %rbp, %rdi
callq 0x35a8
movq 0xa11d(%rip), %rdi      # 0xefd0
movq %r12, %rsi
callq 0x31e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3290
movq %rax, %rdi
movq %r13, %rsi
callq 0x3270
movq %rax, %rdi
leaq 0x520e(%rip), %rsi      # 0xa0e9
callq 0x3290
movq %r13, %rdi
callq 0x35a8
incl %r12d
jmp 0x4e55
movq 0xa0d9(%rip), %rbx      # 0xefd0
leaq 0xa522(%rip), %rsi      # 0xf420
movq %rbx, %rdi
callq 0x3270
leaq 0x51ec(%rip), %rsi      # 0xa0f9
movq %rax, %rdi
callq 0x3290
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3270
leaq 0x51db(%rip), %rsi      # 0xa106
movq %rbx, %rdi
callq 0x3290
leaq 0xa4c6(%rip), %rsi      # 0xf400
movq %rax, %rdi
callq 0x3270
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x4f65
jmp 0x4f5d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/args.cpp
// Function: listFiles(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> listFiles(string dir)
{
    auto list = std::vector<std::string>();

    DIR *dp;
    struct dirent *dirp;
    if ((dp = opendir(dir.c_str())) == NULL){
        cout << ANSI_RED << "Could not find directory \"";
        cout << dir << "\" !\n";
        cout << ANSI_RESET;
    }

    while ((dirp = readdir(dp)) != NULL){
        if (dirp->d_name[0] != '.'){
            string name(dirp->d_name);
            if (name.size() > extension.size()){
                name = name.substr(0, name.size() - extension.size());
            }
            if (!name.empty()){
                list.push_back(name);
            }
        }
    }
    closedir(dp);
    
    return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rdi
callq 0x3420
movq %rax, %r14
testq %rax, %rax
jne 0x5032
movq 0x9fea(%rip), %rdi      # 0xefd0
leaq 0xa433(%rip), %rsi      # 0xf420
callq 0x3270
leaq 0x50d2(%rip), %rsi      # 0xa0cb
movq %rax, %rdi
callq 0x3290
movq 0x9fc8(%rip), %rdi      # 0xefd0
movq %r15, %rsi
callq 0x3270
leaq 0x50cf(%rip), %rsi      # 0xa0e6
movq %rax, %rdi
callq 0x3290
movq 0x9faa(%rip), %rdi      # 0xefd0
leaq 0xa3d3(%rip), %rsi      # 0xf400
callq 0x3270
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r14, %rdi
callq 0x3440
testq %rax, %rax
je 0x50b1
cmpb $0x2e, 0x13(%rax)
je 0x503c
addq $0x13, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x50f0
movq 0x10(%rsp), %rax
movq %rax, %rcx
subq 0xa358(%rip), %rcx      # 0xf3c8
jbe 0x5097
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x32c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x3360
movq %r12, %rdi
callq 0x35a8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x50a7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5138
movq %r15, %rdi
callq 0x35a8
jmp 0x503c
movq %r14, %rdi
callq 0x34b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x50dd
jmp 0x50cc
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x50e0
jmp 0x50dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x5164
movq %r14, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x9982(%rip)      # 0xf580
je 0x5c3f
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x5c13
movq %r14, %rdi
callq 0x7662
pushq $0x28
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
movq %r15, %rdi
callq 0x32a0
movq %rax, %r14
movq 0x994c(%rip), %rsi      # 0xf580
movq %rax, %rdi
callq 0x75ea
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9586(%rip), %rdi      # 0xf670
callq 0x8ec0
movq 0x957a(%rip), %rdi      # 0xf670
xorl %esi, %esi
callq 0x8f94
movq 0x956c(%rip), %rdi      # 0xf670
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x8fe6
movq 0x955b(%rip), %r14      # 0xf670
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6d63
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8fd4
movq %rsp, %rdi
callq 0x35a8
movq 0x952f(%rip), %rdi      # 0xf670
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0x8ffa
movq 0x951c(%rip), %rdi      # 0xf670
xorl %esi, %esi
callq 0x8fa6
movq 0x950e(%rip), %rdi      # 0xf670
pushq $0x4
popq %rsi
movl %ebx, %edx
callq 0x8fe6
movq 0x94fd(%rip), %rdi      # 0xf670
callq 0x8ed6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 0x89bc(%rip), %rdi      # 0xf678
callq 0x900e
testb %al, %al
je 0x6cff
movl 0x89e5(%rip), %eax      # 0xf6b0
movl (%rsp), %ecx
leal (%rax,%rcx), %r15d
decl %r15d
movq %rbx, %rdi
callq 0x79aa
cmpl %eax, %r15d
jae 0x6cff
testb %bpl, %bpl
je 0x6cfc
movq %rbx, %rdi
movl %r15d, %esi
callq 0x79be
movq %rax, %rdi
callq 0x71d4
jmp 0x6cff
movl %r15d, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/draw.cpp
// Function: buildTitle[abi:cxx11](TodoList*)
std::string buildTitle(TodoList *list)
{
    std::string title = "[todo version "+vn+"]";

    unsigned cent = (COLS - list->name.size() - 2) / 2;

    for (unsigned i = title.size(); i < cent; i++){
        title += division;
    }

    title += "[";
    title += list->name;
    title += "]";

    std::string stats = "[" + list->completedStr() + "]";

    for (unsigned i = title.size() + stats.size(); i < (unsigned)COLS; i++){
        title += division;
    }

    title += stats;
    return title;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x37b9(%rip), %rsi      # 0xa537
leaq 0x880b(%rip), %rdx      # 0xf590
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5c9c
leaq 0x3271(%rip), %rdx      # 0xa00a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5c7d
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq 0x81f3(%rip), %r13      # 0xefa8
movslq (%r13), %rax
leaq 0x8(%r14), %rcx
movq %rcx, (%rsp)
subq 0x10(%r14), %rax
movabsq $0x1fffffffe, %rbp      # imm = 0x1FFFFFFFE
addq %rax, %rbp
shrq %rbp
movl 0x8(%rbx), %r15d
leaq 0x8830(%rip), %r12      # 0xf610
cmpl %ebp, %r15d
jae 0x6df5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3590
incl %r15d
jmp 0x6de0
leaq 0x3688(%rip), %rsi      # 0xa484
movq %rbx, %rdi
callq 0x3550
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x3590
leaq 0x31f3(%rip), %rsi      # 0xa00a
movq %rbx, %rdi
callq 0x3550
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x7c14
leaq 0x3651(%rip), %rsi      # 0xa484
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x70db
leaq 0x31c1(%rip), %rdx      # 0xa00a
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5c7d
leaq 0x48(%rsp), %rdi
callq 0x35a8
leaq 0x28(%rsp), %rdi
callq 0x35a8
movl 0x10(%rsp), %ebp
addl 0x8(%rbx), %ebp
leaq 0x8796(%rip), %r14      # 0xf610
cmpl (%r13), %ebp
jae 0x6e8f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3590
incl %ebp
jmp 0x6e7a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3590
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ee1
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x35a8
jmp 0x6ecc
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x6ee9
jmp 0x6ef0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x6ef6
jmp 0x6ef0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x6ef3
movq %rax, %r14
movq %rbx, %rdi
callq 0x35a8
movq %r14, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x3
popq %rbp
leaq 0x30f2(%rip), %r15      # 0xa010
leaq 0x20(%rsp), %r12
subl $0x1, %ebp
jb 0x6f4b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5c9c
movq %r14, %rdi
movq %r12, %rsi
callq 0x3360
movq %r12, %rdi
callq 0x35a8
jmp 0x6f23
leaq 0x86be(%rip), %r15      # 0xf610
movl 0x8740(%rip), %eax      # 0xf698
addl $-0x3, %eax
cmpl 0x8(%r14), %eax
jle 0x6f6e
movq %r14, %rdi
movq %r15, %rsi
callq 0x3590
jmp 0x6f52
movq 0x8703(%rip), %r15      # 0xf678
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x33b0
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %ecx
callq 0x8fd4
movq %rsp, %rdi
callq 0x35a8
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 0x86ad(%rip), %rbx      # 0xf670
testq %rbx, %rbx
je 0x6fd0
movq %rbx, %rdi
callq 0x8e8e
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x32b0
movq 0x8696(%rip), %rbx      # 0xf678
testq %rbx, %rbx
je 0x6fef
movq %rbx, %rdi
callq 0x8e8e
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x32b0
movq 0x867f(%rip), %rbx      # 0xf680
testq %rbx, %rbx
je 0x700e
movq %rbx, %rdi
callq 0x8e8e
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x32b0
movq 0x8668(%rip), %rbx      # 0xf688
testq %rbx, %rbx
je 0x702d
movq %rbx, %rdi
callq 0x8e8e
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x32b0
callq 0x3340
pushq $0x1
popq %rdi
popq %rbx
jmp 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x32a8(%rip), %rsi      # 0xa496
leaq 0x8(%rsp), %rdx
callq 0x50f0
leaq 0x8519(%rip), %rax      # 0xf718
leaq 0x84f2(%rip), %rsi      # 0xf6f8
cmpb $0x0, 0x20(%r14)
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x3590
leaq 0x32c1(%rip), %rsi      # 0xa4df
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x5c9c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3590
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x7261
jmp 0x725e
movq %rax, %r14
movq %rbx, %rdi
callq 0x35a8
movq %r14, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3210(%rip), %rsi      # 0xa496
leaq 0x8(%rsp), %rdx
callq 0x50f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3590
leaq 0x3377(%rip), %rsi      # 0xa619
movq %rbx, %rdi
callq 0x3550
movzbl 0x20(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x746b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3590
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x72ef
jmp 0x72ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x35a8
movq %r14, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
xorl %eax, %eax
leaq 0x8(%rsp), %r12
leaq 0x32f6(%rip), %rbp      # 0xa619
movl %eax, %r13d
movq 0x8(%r14), %rdx
leaq -0x1(%rdx), %rax
cmpq %r13, %rax
jbe 0x73d4
movq %r13, %r15
notq %r15
addq %r15, %rdx
movq %r12, %rdi
movq %r14, %rsi
pushq $0x1
popq %rcx
callq 0x32c0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x512b
movl %eax, %ebx
movq %r12, %rdi
callq 0x35a8
leal 0x1(%r13), %eax
testb %bl, %bl
je 0x7323
movq 0x8(%r14), %rdx
subq %r13, %rdx
leaq 0x8(%rsp), %rbx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x2c7a(%rip), %rsi      # 0xa006
movq %rbx, %rdi
callq 0x512b
movl %eax, %ebp
movq %rbx, %rdi
callq 0x35a8
testb %bpl, %bpl
je 0x73a8
movb $0x1, 0x20(%r14)
addq 0x8(%r14), %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x32c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3360
movq %rbx, %rdi
callq 0x35a8
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7046
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_O2/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 0x40dc
testb %al, %al
jne 0x7571
callq 0x5d70
callq 0x54f0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4f72
movq %rbx, %rdi
callq 0x5528
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x35a8
movq %rsp, %rbx
movq %r14, (%rbx)
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movq 0x7aac(%rip), %r15      # 0xefc8
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x60b3
movq (%r15), %rdi
callq 0x3140
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5599
testb %al, %al
je 0x751c
callq 0x6fbb
callq 0x5507
movq (%rsp), %rdi
callq 0x7698
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x7566
movq %rbx, %rdi
callq 0x7662
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x32b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x77da
movq (%r14), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x3180
movq %r14, %rdi
callq 0x35a8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7870
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x3580
leaq 0x8(%rsp), %rdi
callq 0x35a8
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x771d
movq 0x78c1(%rip), %rdi      # 0xefd0
leaq 0x2f0a(%rip), %rsi      # 0xa620
callq 0x3290
jmp 0x7788
xorl %ebp, %ebp
pushq $0x28
popq %r13
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x29b5(%rip), %r12      # 0xa0e9
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r13
cmpl %eax, %ebp
jae 0x777e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x79be
movq %r14, %rdi
movq %rax, %rsi
callq 0x7272
movq %r15, %rdi
movq %r14, %rsi
callq 0x3270
movq %rax, %rdi
movq %r12, %rsi
callq 0x3290
movq %r14, %rdi
callq 0x35a8
incl %ebp
jmp 0x7734
leaq 0x28(%rsp), %rdi
callq 0x33d0
leaq 0x28(%rsp), %rdi
callq 0x33f0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x77c4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x77d1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x77c7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x33f0
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::load()
void TodoList::load()
{
    if (!exists()){
        return;
    }

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

    unsigned pos = 0;
    for (string line = ""; getline(file, line); pos++){
        add(Task(line).parse(), pos);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %rbx
callq 0x7b5e
testb %al, %al
je 0x7ae9
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7870
leaq 0x90(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x34c0
movq %rsp, %rdi
callq 0x35a8
movq 0x90(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0xb0(%rsp,%rax)
je 0x7a42
movq 0x759f(%rip), %rdi      # 0xefd0
leaq 0x2be8(%rip), %rsi      # 0xa620
callq 0x3290
jmp 0x7adc
leaq 0x2a4d(%rip), %rsi      # 0xa496
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
callq 0x50f0
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
leaq 0x48(%rsp), %r12
movq %rsp, %r13
leaq 0x68(%rsp), %r14
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x30b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7ad2
movq %r12, %rdi
movq %r15, %rsi
callq 0x33b0
movq %r13, %rdi
movq %r12, %rsi
callq 0x7198
movq %r14, %rdi
movq %r13, %rsi
callq 0x7300
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7b9e
movq %r14, %rdi
callq 0x35a8
movq %r13, %rdi
callq 0x35a8
movq %r12, %rdi
callq 0x35a8
incl %ebp
jmp 0x7a6a
leaq 0x28(%rsp), %rdi
callq 0x35a8
leaq 0x90(%rsp), %rdi
callq 0x30f0
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7afd
movq %rax, %rbx
jmp 0x7b49
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
jmp 0x7b56
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x35a8
jmp 0x7b21
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
jmp 0x7b30
jmp 0x7b3c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x35a8
jmp 0x7b3f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35a8
leaq 0x90(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x28
popq %r15
xorl %ebp, %ebp
movq (%r14), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r15
cmpl %eax, %ebp
jae 0x7c06
movq %r14, %rdi
movl %ebp, %esi
callq 0x79be
movq %rax, %rdi
callq 0x744a
movzbl %al, %eax
addl %eax, %ebx
incl %ebp
jmp 0x7bd8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::completedStr[abi:cxx11]()
string TodoList::completedStr()
{
    unsigned count = 0;
    unsigned comp = 0;
    for (unsigned i = 0; i < size(); i++){
        if (at(i).div()){
            continue;
        }
        count++;
        if (at(i).completed()){
            comp++;
        }
    }

    string info = std::to_string(comp) + "/" + std::to_string(count);
    info += " -> ";
    if (size() == 0){
        info += " NaN";
    } else {
        info += std::to_string((int) ((float) comp / (float) count * 100));
        info += "%";
    }
    
    return info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
pushq $0x28
popq %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
movq (%r15), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r13
cmpl %eax, %r12d
jae 0x7c7f
movq %r15, %rdi
movl %r12d, %esi
callq 0x79be
movq %rax, %rdi
callq 0x7404
testb %al, %al
jne 0x7c7a
incl %ebp
movq %r15, %rdi
movl %r12d, %esi
callq 0x79be
movq %rax, %rdi
callq 0x744a
movzbl %al, %eax
addl %eax, %r14d
incl %r12d
jmp 0x7c34
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x7064
leaq 0x29a7(%rip), %rdx      # 0xa63d
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x5c7d
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x7064
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x7fc3
leaq 0x28(%rsp), %rdi
callq 0x35a8
leaq 0x8(%rsp), %rdi
callq 0x35a8
leaq 0x48(%rsp), %rdi
callq 0x35a8
leaq 0x2959(%rip), %rsi      # 0xa63f
movq %rbx, %rdi
callq 0x3550
movq (%r15), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r13
testl %eax, %eax
je 0x7d4a
movl %r14d, %eax
cvtsi2ss %rax, %xmm0
movl %ebp, %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
mulss 0x2900(%rip), %xmm0     # 0xa61c
cvttss2si %xmm0, %esi
leaq 0x8(%rsp), %rdi
callq 0x746b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3590
leaq 0x8(%rsp), %rdi
callq 0x35a8
leaq 0x2901(%rip), %rsi      # 0xa649
jmp 0x7d51
leaq 0x28f3(%rip), %rsi      # 0xa644
movq %rbx, %rdi
callq 0x3550
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x7da7
jmp 0x7da4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x35a8
jmp 0x7d8e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35a8
jmp 0x7d9d
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x7daa
movq %rax, %r14
movq %rbx, %rdi
callq 0x35a8
movq %r14, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
pushq $0x28
popq %r8
cqto
idivq %r8
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x7de7
imulq $0x28, %rcx, %rax
addq %rax, %rsi
callq 0x80c2
movq %rbx, %rdi
popq %rbx
jmp 0x7698
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl %esi, %ebx
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
decl %r14d
cmpl %esi, %r14d
jbe 0x7e7c
movl %ebx, %r13d
movq %r13, %rsi
callq 0x51a8
movq %rsp, %rdi
movq %rax, %rsi
callq 0x7046
movq (%r15), %rdi
leal 0x1(%rbx), %r12d
movq %r12, %rsi
callq 0x51a8
movq %rax, %rbp
movq (%r15), %rdi
movq %r13, %rsi
callq 0x51a8
movq %rax, %rdi
movq %rbp, %rsi
callq 0x80c8
movq (%r15), %rdi
movq %r12, %rsi
callq 0x51a8
movq %rsp, %rsi
movq %rax, %rdi
callq 0x80c8
movq %rsp, %rdi
callq 0x35a8
cmpl %ebx, %r14d
seta %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r12d, %r12d
pushq $0x28
popq %r13
leaq -0xa72(%rip), %r14      # 0x744e
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
cqto
idivq %r13
movl %eax, %eax
cmpq %rax, %r15
jae 0x7f38
movq %r15, %rsi
callq 0x51a8
movq %rax, %rdi
callq 0x7404
movq (%rbx), %rdx
movl %ebp, %ecx
testb %al, %al
je 0x7f03
movq (%rdx), %rsi
imulq $0x28, %rcx, %rdi
addq %rsi, %rdi
addq %r12, %rsi
jmp 0x7f23
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r13
decl %eax
cmpq %rax, %r15
jne 0x7f2f
imulq $0x28, %rcx, %rax
addq %rax, %rdi
movq %r14, %rdx
callq 0x852a
leal 0x1(%r15), %ebp
incq %r15
addq $0x28, %r12
jmp 0x7ec5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/phillip-h[P]todo/src/typer.cpp
// Function: type(Win*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string type(Win *win, unsigned size, string base)
{
    char* buf = new char[size];
    for (unsigned i = 0; i < size; i++)
        buf[i] = i < base.size() ? base.at(i) : 0;
    unsigned pos = base.size();
   
    curs_set(1);

    int in;
    bool typing = true;
    while(typing){

        win->clear();
        win->print(string(buf));
        win->color(BORDER_COLOR_PAIR, true);       
        win->draw();
        
        switch(in = getch()){
            case 27: // ESCAPE
                curs_set(0);
                return base;
            case '\n':
                typing = false;
                break;
            case KEY_BACKSPACE:
                if (pos)
                    pos--;
                buf[pos] = 0;
                break;
            default:
                buf[pos] = in;
                if (pos < size)
                    pos++;
                break;
        }
    }
    
    curs_set(0);

    string ret(buf);
    delete[] buf;
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %edx, %ebx
movq %rbx, %rdi
callq 0x3030
movq %rax, %r15
xorl %r13d, %r13d
movq 0x8(%r14), %rbp
cmpq %r13, %rbx
je 0x8cf9
cmpq %r13, %rbp
jbe 0x8cee
movq %r14, %rdi
movq %r13, %rsi
callq 0x3570
movb (%rax), %al
jmp 0x8cf0
xorl %eax, %eax
movb %al, (%r15,%r13)
incq %r13
jmp 0x8cd1
pushq $0x1
popq %rdi
callq 0x3240
leaq 0x18(%rsp), %rbx
movq 0x62bb(%rip), %r13      # 0xefc8
movq %r12, %rdi
callq 0x8ec0
movq %rbx, %rdi
movq %r15, %rsi
leaq 0xb(%rsp), %rdx
callq 0x50f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8fc6
movq %rbx, %rdi
callq 0x35a8
movq %r12, %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x8fe6
movq %r12, %rdi
callq 0x8ed6
movq (%r13), %rdi
callq 0x3140
cmpl $0x107, %eax            # imm = 0x107
je 0x8d77
cmpl $0xa, %eax
je 0x8d89
cmpl $0x1b, %eax
je 0x8daf
movl %ebp, %ecx
movb %al, (%r15,%rcx)
cmpl 0xc(%rsp), %ebp
adcl $0x0, %ebp
jmp 0x8d0d
subl $0x1, %ebp
movl $0x0, %eax
cmovbl %eax, %ebp
movb $0x0, (%r15,%rbp)
jmp 0x8d0d
xorl %edi, %edi
callq 0x3240
leaq 0xb(%rsp), %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50f0
movq %r15, %rdi
callq 0x3390
jmp 0x8dc6
xorl %edi, %edi
callq 0x3240
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb $0x0, 0x30(%rdi)
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movq %r14, %rdi
movq %r9, %rsi
callq 0x31b0
movl %ebp, %edi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
callq 0x32d0
movb 0x40(%rsp), %cl
movq %rax, 0x8(%rbx)
testb %cl, %cl
je 0x8e59
addl $-0x2, %ebp
addl $-0x2, %r15d
incl %r12d
incl %r13d
movl %ebp, %edi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
callq 0x32d0
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3540
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8f94
movq 0x8(%rbx), %r14
leaq 0x20(%rbx), %rdx
leaq 0x157b(%rip), %rsi      # 0xa484
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x5c9c
leaq 0x10ed(%rip), %rdx      # 0xa00a
movq %rsp, %rdi
movq %r15, %rsi
callq 0x5c7d
movq (%rsp), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x30d0
movq %rsp, %rdi
callq 0x35a8
leaq 0x20(%rsp), %rdi
callq 0x35a8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8fa6
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
callq 0x35a8
jmp 0x8f82
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x35a8
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38e6(%rip), %rsi      # 0x6034
callq 0x294e
testb %al, %al
je 0x275b
xorl %eax, %eax
jmp 0x2782
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
cmpb $0x2d, (%rcx)
sete %sil
cmpq %rdx, %rsi
setae %al
jae 0x2782
movsbl (%rcx,%rsi), %edi
addl $-0x30, %edi
incq %rsi
cmpl $0xa, %edi
jb 0x276b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %r13
leaq 0x3921(%rip), %rbp      # 0x6171
leaq 0x8(%rsp), %r12
movq %r13, %r15
addq 0x8(%r14), %r13
cmpq %r13, %r15
je 0x28fe
movsbl (%r15), %edi
callq 0x2040
testl %eax, %eax
je 0x2877
incq %r15
jmp 0x285c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x22f0
movsbl (%r15), %r13d
movl %r13d, %edi
callq 0x2280
testl %eax, %eax
je 0x28b8
movq %rbp, %r13
movsbl (%r15), %ebp
movl %ebp, %edi
callq 0x2280
testl %eax, %eax
je 0x28b3
incq %r15
movq %r12, %rdi
movl %ebp, %esi
callq 0x2190
jmp 0x2895
movq %r13, %rbp
jmp 0x28eb
leal -0x30(%r13), %eax
cmpl $0x9, %eax
ja 0x28dd
movsbl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x28eb
incq %r15
movsbl %al, %esi
movq %r12, %rdi
callq 0x2190
jmp 0x28c1
movq %r12, %rdi
movl %r13d, %esi
callq 0x2190
incq %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x295c
movq (%r14), %r13
jmp 0x2858
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2920
jmp 0x2920
jmp 0x2920
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2988
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/cla7aye15I4nd[P]basic_interpreter/./lib/terminal.hpp
// Function: basic::terminal::run()
bool run() {
            string command;
            while (true) {
                //std::cerr << "(basic):";
                std::getline(std::cin, command);

                if (command == "QUIT") {
                    //std::cerr << "exit" << std::endl;
                    return 0;
                }

                if (command == "HELP") {
                    std::cout << "Minimal BASIC Interpreter";
                } else if (command == "CLEAR") {
                    code.clear();
                } else if (command == "RUN") {
                    code.run();
                } else if (command == "LIST") {
                    code.show();
                } else{
                    expression expr = format(command);
                    if (is_digit(expr[0])) {
                        if (!code.insert(expr))
                            std::cout << "SYNTAX ERROR" << std::endl;
                    } else {
                        if (!code.feedback(expr))
                            std::cout << "SYNTAX ERROR" << std::endl;
                    }
                }
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x74f5(%rip), %r14      # 0x9fe0
leaq 0x18(%rsp), %r15
leaq 0x3565(%rip), %r12      # 0x605c
leaq 0x3563(%rip), %r13      # 0x6061
movq 0x74cb(%rip), %rbp      # 0x9fd0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
movq %r15, %rdi
movq %r12, %rsi
callq 0x294e
testb %al, %al
jne 0x2bf5
movq %r15, %rdi
movq %r13, %rsi
callq 0x294e
testb %al, %al
je 0x2b43
movq %rbp, %rdi
leaq 0x352a(%rip), %rsi      # 0x6066
callq 0x21c0
jmp 0x2b05
movq %r15, %rdi
leaq 0x3533(%rip), %rsi      # 0x6080
callq 0x294e
testb %al, %al
je 0x2b60
movq %rbx, %rdi
callq 0x2e18
jmp 0x2b05
movq %r15, %rdi
leaq 0x351c(%rip), %rsi      # 0x6086
callq 0x294e
testb %al, %al
je 0x2b7d
movq %rbx, %rdi
callq 0x2e2e
jmp 0x2b05
movq %r15, %rdi
leaq 0x3503(%rip), %rsi      # 0x608a
callq 0x294e
testb %al, %al
je 0x2b9d
movq %rbx, %rdi
callq 0x2fbc
jmp 0x2b05
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2816
movq (%rsp), %rdi
callq 0x2743
testb %al, %al
je 0x2bc2
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x3018
jmp 0x2bcd
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x3172
testb %al, %al
jne 0x2be8
movq %rbp, %rdi
leaq 0x34b4(%rip), %rsi      # 0x608f
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movq %rsp, %rdi
callq 0x2988
jmp 0x2b05
leaq 0x18(%rsp), %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c1f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2988
jmp 0x2c22
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22d0