LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: usage()
void usage() {    
    ccout << "todo usage\n";
    ccout << "----------\n";
    ccout << "todo <command> [<parameters>]\n";
    ccout << "Begin with todo init.\n\n";
    ccout << "COMMAND          DESCRIPTION\n";
    ccout << "-------          -----------\n";
    ccout << "init           - Initialize .todo file\n";
    ccout << "global <cmd>   - Perform any of these commands on the user-level .todo\n";
    ccout << "add <todo>     - Add a new todo\n";
    ccout << "<no args>      - Display todos in .todo\n";
    ccout << "complete <num> - Complete the given todo\n";
    ccout << "sweep          - Clear all completed todos from the list\n";
    ccout << "delete <num>   - Remove a todo from the list\n";
    ccout << "purge          - Removed ALL TODOS from the list\n";
    ccout << "help           - Display this list\n";
    ccout << "version        - Show version information\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe4265(%rip), %rdi     # 0xfa440
leaq 0xa6e26(%rip), %rsi     # 0xbd008
callq 0x83450
leaq 0xe4252(%rip), %rdi     # 0xfa440
leaq 0xa6e86(%rip), %rsi     # 0xbd07b
callq 0x83450
leaq 0xe423f(%rip), %rdi     # 0xfa440
leaq 0xa6e0c(%rip), %rsi     # 0xbd014
callq 0x83450
leaq 0xe422c(%rip), %rdi     # 0xfa440
leaq 0xa6e18(%rip), %rsi     # 0xbd033
callq 0x83450
leaq 0xe4219(%rip), %rdi     # 0xfa440
leaq 0xa6e1d(%rip), %rsi     # 0xbd04b
callq 0x83450
leaq 0xe4206(%rip), %rdi     # 0xfa440
leaq 0xa6e28(%rip), %rsi     # 0xbd069
callq 0x83450
leaq 0xe41f3(%rip), %rdi     # 0xfa440
leaq 0xa6e33(%rip), %rsi     # 0xbd087
callq 0x83450
leaq 0xe41e0(%rip), %rdi     # 0xfa440
leaq 0xa6e48(%rip), %rsi     # 0xbd0af
callq 0x83450
leaq 0xe41cd(%rip), %rdi     # 0xfa440
leaq 0xa6e7d(%rip), %rsi     # 0xbd0f7
callq 0x83450
leaq 0xe41ba(%rip), %rdi     # 0xfa440
leaq 0xa6e8b(%rip), %rsi     # 0xbd118
callq 0x83450
leaq 0xe41a7(%rip), %rdi     # 0xfa440
leaq 0xa6ea1(%rip), %rsi     # 0xbd141
callq 0x83450
leaq 0xe4194(%rip), %rdi     # 0xfa440
leaq 0xa6eb8(%rip), %rsi     # 0xbd16b
callq 0x83450
leaq 0xe4181(%rip), %rdi     # 0xfa440
leaq 0xa6edf(%rip), %rsi     # 0xbd1a5
callq 0x83450
leaq 0xe416e(%rip), %rdi     # 0xfa440
leaq 0xa6efa(%rip), %rsi     # 0xbd1d3
callq 0x83450
leaq 0xe415b(%rip), %rdi     # 0xfa440
leaq 0xa6f19(%rip), %rsi     # 0xbd205
callq 0x83450
leaq 0xe4148(%rip), %rdi     # 0xfa440
leaq 0xa6f2a(%rip), %rsi     # 0xbd229
callq 0x83450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: match_one_or_more(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool match_one_or_more(std::string input, std::string compare) {
    if(input.length() > 0 && compare.length() > 0) {
        std::string command = compare;
        if(input.length() < command.length()) {
            command = command.substr(0, input.length());
        }

        return input.compare(command) == 0;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x89a50
cmpq $0x0, %rax
jbe 0x1642b
movq -0x70(%rbp), %rdi
callq 0x89a50
cmpq $0x0, %rax
jbe 0x1642b
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8bfb0
movq -0x78(%rbp), %rdi
callq 0x89a50
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x89a50
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x163fa
movq -0x78(%rbp), %rdi
callq 0x89a50
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8c1d0
jmp 0x163cb
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x89870
leaq -0x58(%rbp), %rdi
callq 0x89820
jmp 0x163fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x89820
jmp 0x1643d
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8b880
movl %eax, -0x84(%rbp)
jmp 0x1640f
movl -0x84(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x89820
jmp 0x1642f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: todo_init(bool)
void todo_init(bool is_local) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(is_local) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "w");
    if(fp) {
        ccout << "Created " << path << std::endl;
        fclose(fp);
    } else {
        ccout << "Error creating " << path << std::endl;
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
callq 0x16310
movq %rax, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
je 0x16490
leaq -0x1010(%rbp), %rdi
leaq 0xa6dd9(%rip), %rsi     # 0xbd259
leaq 0xa6ddb(%rip), %rdx     # 0xbd262
movb $0x0, %al
callq 0x12370
jmp 0x164b0
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa6dc2(%rip), %rsi     # 0xbd264
leaq 0xa6db9(%rip), %rcx     # 0xbd262
movb $0x0, %al
callq 0x12370
leaq -0x1010(%rbp), %rdi
leaq 0xaac38(%rip), %rsi     # 0xc10f6
callq 0x121f0
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
je 0x16513
leaq 0xe3f65(%rip), %rdi     # 0xfa440
leaq 0xa6d8c(%rip), %rsi     # 0xbd26e
callq 0x83450
movq %rax, %rdi
leaq -0x1010(%rbp), %rsi
callq 0x83450
movq %rax, %rdi
leaq 0x6c830(%rip), %rsi     # 0x82d30
callq 0x81f40
movq -0x1018(%rbp), %rdi
callq 0x12570
jmp 0x16544
leaq 0xe3f26(%rip), %rdi     # 0xfa440
leaq 0xa6d56(%rip), %rsi     # 0xbd277
callq 0x83450
movq %rax, %rdi
leaq -0x1010(%rbp), %rsi
callq 0x83450
movq %rax, %rdi
leaq 0x6c7f1(%rip), %rsi     # 0x82d30
callq 0x81f40
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopl (%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: get_todos[abi:cxx11](bool)
std::vector<std::string> get_todos(bool local_mode)  {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local_mode) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "r");
    std::vector<std::string> buffer;
    if(fp) {
        do {
            char line[PATHMAX];
            char* res = fgets(line, PATHMAX, fp);
            if(res) {
                buffer.push_back(std::string(res));
            } else {
                break;
            }
        } while(true);
        fclose(fp);
    } else {
        usage();        
    }    
    
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20a0, %rsp           # imm = 0x20A0
movq %rdi, -0x2080(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x2078(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x16310
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x165a5
leaq -0x1020(%rbp), %rdi
leaq 0xa6cc4(%rip), %rsi     # 0xbd259
leaq 0xa6cc6(%rip), %rdx     # 0xbd262
movb $0x0, %al
callq 0x12370
jmp 0x165c5
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa6cad(%rip), %rsi     # 0xbd264
leaq 0xa6ca4(%rip), %rcx     # 0xbd262
movb $0x0, %al
callq 0x12370
leaq -0x1020(%rbp), %rdi
leaq 0xab54c(%rip), %rsi     # 0xc1b1f
callq 0x121f0
movq -0x2080(%rbp), %rdi
movq %rax, -0x1028(%rbp)
movb $0x0, -0x1029(%rbp)
callq 0x17340
cmpq $0x0, -0x1028(%rbp)
je 0x16722
jmp 0x16602
movq -0x1028(%rbp), %rdx
leaq -0x2030(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x12260
movq %rax, -0x2088(%rbp)
jmp 0x16623
movq -0x2088(%rbp), %rax
movq %rax, -0x2038(%rbp)
cmpq $0x0, -0x2038(%rbp)
je 0x16702
movq -0x2038(%rbp), %rax
movq %rax, -0x2098(%rbp)
leaq -0x2069(%rbp), %rdi
movq %rdi, -0x2090(%rbp)
callq 0x1b280
movq -0x2098(%rbp), %rsi
movq -0x2090(%rbp), %rdx
leaq -0x2068(%rbp), %rdi
callq 0x17290
jmp 0x1667c
movq -0x2080(%rbp), %rdi
leaq -0x2068(%rbp), %rsi
callq 0x17360
jmp 0x16691
leaq -0x2068(%rbp), %rdi
callq 0x89820
leaq -0x2069(%rbp), %rdi
callq 0x1b2a0
jmp 0x16704
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2040(%rbp)
movl %eax, -0x2044(%rbp)
jmp 0x16757
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2040(%rbp)
movl %eax, -0x2044(%rbp)
jmp 0x166f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2040(%rbp)
movl %eax, -0x2044(%rbp)
leaq -0x2068(%rbp), %rdi
callq 0x89820
leaq -0x2069(%rbp), %rdi
callq 0x1b2a0
jmp 0x16757
jmp 0x16712
jmp 0x16706
movb $0x1, %al
testb $0x1, %al
jne 0x16602
jmp 0x16712
movq -0x1028(%rbp), %rdi
callq 0x12570
jmp 0x16720
jmp 0x1672b
callq 0x161d0
jmp 0x16729
jmp 0x1672b
movb $0x1, -0x1029(%rbp)
testb $0x1, -0x1029(%rbp)
jne 0x16747
movq -0x2080(%rbp), %rdi
callq 0x17390
movq -0x2078(%rbp), %rax
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbp
retq
movq -0x2080(%rbp), %rdi
callq 0x17390
movq -0x2040(%rbp), %rdi
callq 0xba910
nop
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: concat_remainder(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>*)
std::string concat_remainder(std::queue<std::string>* command_list) {
    std::string s;
    while(!command_list->empty()) {
        s += command_list->front();
        command_list->pop();
        if(!command_list->empty()) { s += " "; }
    }

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x89710
movq -0x10(%rbp), %rdi
callq 0x171f0
movb %al, -0x39(%rbp)
jmp 0x167a2
movb -0x39(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x167ad
jmp 0x1681d
movq -0x10(%rbp), %rdi
callq 0x174a0
movq %rax, -0x48(%rbp)
jmp 0x167bc
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x8af40
jmp 0x167cb
movq -0x10(%rbp), %rdi
callq 0x174c0
jmp 0x167d6
movq -0x10(%rbp), %rdi
callq 0x171f0
movb %al, -0x49(%rbp)
jmp 0x167e4
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x16818
jmp 0x167ed
movq -0x38(%rbp), %rdi
leaq 0xa6d68(%rip), %rsi     # 0xbd560
callq 0x8b020
jmp 0x167ff
jmp 0x16818
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x89820
jmp 0x1683a
jmp 0x16794
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x16830
movq -0x38(%rbp), %rdi
callq 0x89820
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: write_todo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void write_todo(std::string msg, bool local_mode) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local_mode) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "a");
    if(fp) {
        fseek(fp, 0, SEEK_END);
        fprintf(fp, "X:%s\n", msg.c_str());
        ccout << "Added!" << std::endl;
        fclose(fp);
    } else {
        ccout << "Error adding todo." << std::endl;
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x1030(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x16310
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1689b
leaq -0x1020(%rbp), %rdi
leaq 0xa69ce(%rip), %rsi     # 0xbd259
leaq 0xa69d0(%rip), %rdx     # 0xbd262
movb $0x0, %al
callq 0x12370
jmp 0x168bb
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa69b7(%rip), %rsi     # 0xbd264
leaq 0xa69ae(%rip), %rcx     # 0xbd262
movb $0x0, %al
callq 0x12370
leaq -0x1020(%rbp), %rdi
leaq 0xaa81e(%rip), %rsi     # 0xc10e7
callq 0x121f0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x16956
movq -0x1028(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x12150
movq -0x1030(%rbp), %rdi
movq -0x1028(%rbp), %rax
movq %rax, -0x1038(%rbp)
callq 0x8b260
movq -0x1038(%rbp), %rdi
movq %rax, %rdx
leaq 0xa697b(%rip), %rsi     # 0xbd29a
movb $0x0, %al
callq 0x12660
leaq 0xe3b13(%rip), %rdi     # 0xfa440
leaq 0xa696c(%rip), %rsi     # 0xbd2a0
callq 0x83450
movq %rax, %rdi
leaq 0x6c3ed(%rip), %rsi     # 0x82d30
callq 0x81f40
movq -0x1028(%rbp), %rdi
callq 0x12570
jmp 0x16978
leaq 0xe3ae3(%rip), %rdi     # 0xfa440
leaq 0xa6943(%rip), %rsi     # 0xbd2a7
callq 0x83450
movq %rax, %rdi
leaq 0x6c3bd(%rip), %rsi     # 0x82d30
callq 0x81f40
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: rewrite_todos(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>>>>, bool)
void rewrite_todos(std::vector<std::string> buffer, bool local) {
    char* userdir = get_userdir();
    char path[PATHMAX];
    if(local) {
        sprintf(path, ".%s.todo", SEPARATOR);
    } else {
        sprintf(path, "%s%s.todo", userdir, SEPARATOR);
    }

    FILE* fp = fopen(path, "w");
    if(fp) {
        for(int i = 0; i < buffer.size(); i++) {
            // This guard here skips any blank lines. This is a little 'cheat' to allow for
            // easier deletion. Just set the respective line to be blank, and it'll be 'skipped' 
            // during output.
            if(buffer[i].length() == 0) { continue; }
            fprintf(fp, "%s", buffer[i].c_str());
        }        
        fclose(fp);        
    } else {
        ccout << "Error updating todos." << std::endl;
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, -0x1038(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x16310
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x169db
leaq -0x1020(%rbp), %rdi
leaq 0xa688e(%rip), %rsi     # 0xbd259
leaq 0xa6890(%rip), %rdx     # 0xbd262
movb $0x0, %al
callq 0x12370
jmp 0x169fb
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa6877(%rip), %rsi     # 0xbd264
leaq 0xa686e(%rip), %rcx     # 0xbd262
movb $0x0, %al
callq 0x12370
leaq -0x1020(%rbp), %rdi
leaq 0xaa6ed(%rip), %rsi     # 0xc10f6
callq 0x121f0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x16adc
movl $0x0, -0x102c(%rbp)
movq -0x1038(%rbp), %rdi
movslq -0x102c(%rbp), %rax
movq %rax, -0x1040(%rbp)
callq 0x173f0
movq %rax, %rcx
movq -0x1040(%rbp), %rax
cmpq %rcx, %rax
jae 0x16ace
movq -0x1038(%rbp), %rdi
movslq -0x102c(%rbp), %rsi
callq 0x17410
movq %rax, %rdi
callq 0x89a50
cmpq $0x0, %rax
jne 0x16a79
jmp 0x16aba
movq -0x1038(%rbp), %rdi
movq -0x1028(%rbp), %rax
movq %rax, -0x1048(%rbp)
movslq -0x102c(%rbp), %rsi
callq 0x17410
movq %rax, %rdi
callq 0x8b260
movq -0x1048(%rbp), %rdi
movq %rax, %rdx
leaq 0xa6807(%rip), %rsi     # 0xbd2ba
movb $0x0, %al
callq 0x12660
movl -0x102c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x102c(%rbp)
jmp 0x16a2d
movq -0x1028(%rbp), %rdi
callq 0x12570
jmp 0x16afe
leaq 0xe395d(%rip), %rdi     # 0xfa440
leaq 0xa67d3(%rip), %rsi     # 0xbd2bd
callq 0x83450
movq %rax, %rdi
leaq 0x6c237(%rip), %rsi     # 0x82d30
callq 0x81f40
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopw (%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: complete_todo(unsigned int, bool)
void complete_todo(unsigned int index, bool local) {
    auto todos = get_todos(local);
    if(todos.size() == 0 || index > todos.size() - 1) {
        ccout << "No item with index " << index << "." << std::endl;
    } else {
        todos[index][0] = 'O';
        ccout << "Item " << index << " completed!" << std::endl;
    }

    rewrite_todos(todos, local);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
leaq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x16550
leaq -0x20(%rbp), %rdi
callq 0x173f0
cmpq $0x0, %rax
je 0x16b66
movl -0x4(%rbp), %eax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x173f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x16bcf
leaq 0xe38d3(%rip), %rdi     # 0xfa440
leaq 0xa675f(%rip), %rsi     # 0xbd2d3
callq 0x83450
movq %rax, -0x58(%rbp)
jmp 0x16b7f
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x83a80
movq %rax, -0x60(%rbp)
jmp 0x16b91
movq -0x60(%rbp), %rdi
leaq 0xaa4b4(%rip), %rsi     # 0xc1050
callq 0x83450
movq %rax, -0x68(%rbp)
jmp 0x16ba7
movq -0x68(%rbp), %rdi
leaq 0x6c17e(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x16bb9
jmp 0x16c51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x16ca2
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x89d60
movq %rax, -0x70(%rbp)
jmp 0x16bef
movq -0x70(%rbp), %rax
movb $0x4f, (%rax)
leaq 0xe3843(%rip), %rdi     # 0xfa440
leaq 0xa66e3(%rip), %rsi     # 0xbd2e7
callq 0x83450
movq %rax, -0x78(%rbp)
jmp 0x16c0f
movq -0x78(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x83a80
movq %rax, -0x80(%rbp)
jmp 0x16c21
movq -0x80(%rbp), %rdi
leaq 0xa66c1(%rip), %rsi     # 0xbd2ed
callq 0x83450
movq %rax, -0x88(%rbp)
jmp 0x16c3a
movq -0x88(%rbp), %rdi
leaq 0x6c0e8(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x16c4f
jmp 0x16c51
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e0
jmp 0x16c60
movzbl -0x5(%rbp), %esi
andl $0x1, %esi
leaq -0x48(%rbp), %rdi
callq 0x16990
jmp 0x16c72
leaq -0x48(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
movq -0x28(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: delete_todo(unsigned int, bool)
void delete_todo(unsigned int index, bool local) {
    auto todos = get_todos(local);
    if(todos.size() == 0 || index > todos.size() - 1) {
        ccout << "No item with index " << index << "." << std::endl;
    } else {
        todos[index] = "";
        ccout << "Item " << index << " deleted." << std::endl;
    }

    rewrite_todos(todos, local);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
leaq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x16550
leaq -0x20(%rbp), %rdi
callq 0x173f0
cmpq $0x0, %rax
je 0x16d16
movl -0x4(%rbp), %eax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x173f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x16d7f
leaq 0xe3723(%rip), %rdi     # 0xfa440
leaq 0xa65af(%rip), %rsi     # 0xbd2d3
callq 0x83450
movq %rax, -0x58(%rbp)
jmp 0x16d2f
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x83a80
movq %rax, -0x60(%rbp)
jmp 0x16d41
movq -0x60(%rbp), %rdi
leaq 0xaa304(%rip), %rsi     # 0xc1050
callq 0x83450
movq %rax, -0x68(%rbp)
jmp 0x16d57
movq -0x68(%rbp), %rdi
leaq 0x6bfce(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x16d69
jmp 0x16df3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x16e44
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
leaq 0xa6502(%rip), %rsi     # 0xbd299
callq 0x8a870
jmp 0x16d9e
leaq 0xe369b(%rip), %rdi     # 0xfa440
leaq 0xa653b(%rip), %rsi     # 0xbd2e7
callq 0x83450
movq %rax, -0x70(%rbp)
jmp 0x16db7
movq -0x70(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x83a80
movq %rax, -0x78(%rbp)
jmp 0x16dc9
movq -0x78(%rbp), %rdi
leaq 0xa6525(%rip), %rsi     # 0xbd2f9
callq 0x83450
movq %rax, -0x80(%rbp)
jmp 0x16ddf
movq -0x80(%rbp), %rdi
leaq 0x6bf46(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x16df1
jmp 0x16df3
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e0
jmp 0x16e02
movzbl -0x5(%rbp), %esi
andl $0x1, %esi
leaq -0x48(%rbp), %rdi
callq 0x16990
jmp 0x16e14
leaq -0x48(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
movq -0x28(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: sweep_todos(bool)
void sweep_todos(bool local) {
    auto todos = get_todos(local);
    int count = 0;
    for(int i = 0; i < todos.size(); i++) {
        if(todos[i].length() > 2) {
            if(todos[i][0] != 'X') {
                todos[i] = "";
                count++;
            }
        }
    }
    
    rewrite_todos(todos, local);
    ccout << "Removed " << count << " completed todo" << (count > 1 ? "s" : "") << " from the list!" << std::endl;     
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
leaq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x16550
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x173f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x16f45
movslq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
callq 0x89a50
cmpq $0x2, %rax
jbe 0x16f35
movslq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x89d60
movq %rax, -0x60(%rbp)
jmp 0x16eed
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
je 0x16f33
movslq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
leaq 0xa6389(%rip), %rsi     # 0xbd299
callq 0x8a870
jmp 0x16f17
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16f33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1702c
jmp 0x16f35
jmp 0x16f37
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x16e92
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e0
jmp 0x16f54
movzbl -0x1(%rbp), %esi
andl $0x1, %esi
leaq -0x50(%rbp), %rdi
callq 0x16990
jmp 0x16f66
leaq -0x50(%rbp), %rdi
callq 0x17390
leaq 0xe34ca(%rip), %rdi     # 0xfa440
leaq 0xa6386(%rip), %rsi     # 0xbd303
callq 0x83450
movq %rax, -0x68(%rbp)
jmp 0x16f88
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x837f0
movq %rax, -0x70(%rbp)
jmp 0x16f9a
movq -0x70(%rbp), %rdi
leaq 0xa6367(%rip), %rsi     # 0xbd30c
callq 0x83450
movq %rax, -0x78(%rbp)
jmp 0x16fb0
movq -0x78(%rbp), %rdi
movl -0x24(%rbp), %eax
subl $0x2, %eax
leaq 0xa62fa(%rip), %rax     # 0xbd2bb
leaq 0xa62d1(%rip), %rsi     # 0xbd299
cmovgeq %rax, %rsi
callq 0x83450
movq %rax, -0x80(%rbp)
jmp 0x16fd7
movq -0x80(%rbp), %rdi
leaq 0xa633a(%rip), %rsi     # 0xbd31c
callq 0x83450
movq %rax, -0x88(%rbp)
jmp 0x16ff0
movq -0x88(%rbp), %rdi
leaq 0x6bd32(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x17005
leaq -0x20(%rbp), %rdi
callq 0x17390
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
movq -0x30(%rbp), %rdi
callq 0xba910
nop
// File: 64Mega[P]todo-cli/src/todo.cpp
// Function: purge_todos(bool)
void purge_todos(bool local) {
    auto todos = get_todos(local);
    int count = 0;
    for(int i = 0; i < todos.size(); i++) {
        if(todos[i].length() > 2) {            
            todos[i] = "";
            count++;            
        }
    }
    
    rewrite_todos(todos, local);
    ccout << "Deleted " << count << " todo" << (count > 1 ? "s" : "") << " from the list." << std::endl;     
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
leaq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x16550
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x173f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x170f1
movslq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
callq 0x89a50
cmpq $0x2, %rax
jbe 0x170e4
movslq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x17410
movq %rax, %rdi
leaq 0xa61d8(%rip), %rsi     # 0xbd299
callq 0x8a870
jmp 0x170c8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x170e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x171d2
jmp 0x170e6
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x17072
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x174e0
jmp 0x17100
movzbl -0x1(%rbp), %esi
andl $0x1, %esi
leaq -0x50(%rbp), %rdi
callq 0x16990
jmp 0x17112
leaq -0x50(%rbp), %rdi
callq 0x17390
leaq 0xe331e(%rip), %rdi     # 0xfa440
leaq 0xa6203(%rip), %rsi     # 0xbd32c
callq 0x83450
movq %rax, -0x60(%rbp)
jmp 0x17134
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x837f0
movq %rax, -0x68(%rbp)
jmp 0x17146
movq -0x68(%rbp), %rdi
leaq 0xa61c5(%rip), %rsi     # 0xbd316
callq 0x83450
movq %rax, -0x70(%rbp)
jmp 0x1715c
movq -0x70(%rbp), %rdi
movl -0x24(%rbp), %eax
subl $0x2, %eax
leaq 0xa614e(%rip), %rax     # 0xbd2bb
leaq 0xa6125(%rip), %rsi     # 0xbd299
cmovgeq %rax, %rsi
callq 0x83450
movq %rax, -0x78(%rbp)
jmp 0x17183
movq -0x78(%rbp), %rdi
leaq 0xa61a7(%rip), %rsi     # 0xbd335
callq 0x83450
movq %rax, -0x80(%rbp)
jmp 0x17199
movq -0x80(%rbp), %rdi
leaq 0x6bb8c(%rip), %rsi     # 0x82d30
callq 0x81f40
jmp 0x171ab
leaq -0x20(%rbp), %rdi
callq 0x17390
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x17390
leaq -0x20(%rbp), %rdi
callq 0x17390
movq -0x30(%rbp), %rdi
callq 0xba910
nopw %cs:(%rax,%rax)
nop
// File: aleden[P]ptrace-multi-threaded-demo/ptrace_multi_threaded_demo.cpp
// Function: do_child(int, char**)
int do_child(int argc, char **argv) {
  //
  // child
  //

  //
  // the request
  //
  ptrace(PTRACE_TRACEME);
  //
  // turns the calling thread into a tracee.  The thread continues to run
  // (doesn't enter ptrace-stop).  A common practice is to follow the
  // PTRACE_TRACEME with
  //
  raise(SIGSTOP);
  //
  // and allow the parent (which is our tracer now) to observe our
  // signal-delivery-stop.
  //

  constexpr unsigned NUM_THREADS = 3;

  array<thread, NUM_THREADS> thds;
  for (unsigned i = 0; i < NUM_THREADS; i++)
    thds[i] = thread(do_thread, i+1);

  for (thread& thd : thds)
    thd.join();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
movb $0x0, %al
callq 0x2100
movl $0x13, %edi
callq 0x2150
movl $0x3, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4880
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jae 0x25c5
movl -0x34(%rbp), %eax
incl %eax
movl %eax, -0x44(%rbp)
leaq 0x1a2f(%rip), %rsi      # 0x3fa0
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rdx
callq 0x48d0
jmp 0x2580
movl -0x34(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x4990
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x49c0
leaq -0x40(%rbp), %rdi
callq 0x4a00
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x255c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4a70
jmp 0x2628
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4a30
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4a50
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x70(%rbp), %rax
je 0x2614
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x21c0
jmp 0x2604
jmp 0x2606
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x25e7
leaq -0x30(%rbp), %rdi
callq 0x4a70
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: aleden[P]ptrace-multi-threaded-demo/ptrace_multi_threaded_demo.cpp
// Function: do_thread(int)
static void do_thread(int n) {
  for (int i = 1;; ++i) {
    {
      lock_guard<mutex> lck(mtx);
      fprintf(stdout, "child: %d [%d]\n", i,
              static_cast<int>(syscall(SYS_gettid)));
    }

    struct timespec tm;
    clock_gettime(CLOCK_MONOTONIC, &tm);
    tm.tv_sec += 3;
    clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &tm, NULL);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x8193(%rip), %rsi      # 0xc150
callq 0x4b00
movq 0x7ff7(%rip), %rax      # 0xbfc0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0xba, %edi
movb $0x0, %al
callq 0x2040
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movl %eax, %ecx
leaq 0x3999(%rip), %rsi      # 0x798b
movb $0x0, %al
callq 0x2180
leaq -0x10(%rbp), %rdi
callq 0x4b30
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x2130
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movl $0x1, %esi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl %esi, %edi
callq 0x21e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3fb2
nop
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: parse_symlevel(char**, char*)
int parse_symlevel(char *sym[4], char * sym_str) {
    int count = 0;
    bool hasvalue = false;
    ArgParser args{sym_str};
    while (args.next()) {
        args.capture();
        sym[count++] = args.value;
        hasvalue = false;
        if (count == 4) return 4;
    }
    for (int i = count; i < 4; i++ ) sym[i] =NULL;
    return count;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x49a0
leaq 0x8(%rsp), %rdi
callq 0x49d0
testb $0x1, %al
jne 0x369a
jmp 0x36da
leaq 0x8(%rsp), %rdi
callq 0x4b10
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2c(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x0, 0x2b(%rsp)
cmpl $0x4, 0x2c(%rsp)
jne 0x36d8
movl $0x4, 0x44(%rsp)
jmp 0x3710
jmp 0x368a
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x3708
movq 0x38(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x36e2
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: parse_keycode(xkb_keymap*, char*)
xkb_keycode_t parse_keycode(xkb_keymap *keymap, char * keycode) {
    if (keycode == NULL) return -1;
    if (*keycode == '<') {
        char * end = strchr(keycode+1, '>');
        if (end != NULL) {
            *end = '\0';
            int x = xkb_keymap_key_by_name(keymap, keycode+1);
            if (x > 7) {
                *end = '>';
                return x;
            } else {
                fprintf(stderr,"CONFIG ERROR: unknown key: <%s>\n", keycode +1);
                exit(1);
            }
        }
    } else {
        return atoi(keycode) + 8; //Convert from evdev keycode to XKB
    }
    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3743
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x37f4
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x37d9
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
movl $0x3e, %esi
callq 0x3090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x37d7
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x30b0
movl %eax, 0x4(%rsp)
cmpl $0x7, 0x4(%rsp)
jle 0x37ac
movq 0x8(%rsp), %rax
movb $0x3e, (%rax)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x37f4
movq 0x6845(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
leaq 0x3532(%rip), %rsi      # 0x6cf8
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x3220
jmp 0x37ec
movq 0x10(%rsp), %rdi
callq 0x3210
addl $0x8, %eax
movl %eax, 0x24(%rsp)
jmp 0x37f4
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: parse_raw_tap(int, xkb_keymap*, unsigned int*, char*)
void parse_raw_tap(int line, xkb_keymap *keymap, xkb_keycode_t keys[2], char *arguments) {
    ArgParser args{arguments};
    int count = 0;
    while (args.next()) {
        xkb_keycode_t keycode = parse_keycode(keymap, args.value);
        if (keycode < 0) {
            fprintf(stderr,"CONFIG ERROR[line:%d]: unknown key: %s\n",line, args.value);
            exit(1);
        }
        if (count > 1) {
            fprintf(stderr,"CONFIG ERROR[line:%d]: to many for raw keys specified, max is 2",line);
            exit(1);
        }
        keys[count++] = keycode;
    }
    for (int i = count; i < 2; i++) keys[i] = -1;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x49a0
movl $0x0, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x49d0
testb $0x1, %al
jne 0x3841
jmp 0x38d4
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3720
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jae 0x3886
movq 0x6796(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
movq 0x28(%rsp), %rcx
leaq 0x34a4(%rip), %rsi      # 0x6d19
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x3220
cmpl $0x1, 0x14(%rsp)
jle 0x38b3
movq 0x6764(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
leaq 0x349f(%rip), %rsi      # 0x6d41
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x3220
movl 0x10(%rsp), %edx
movq 0x40(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x14(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x382e
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x3901
movq 0x40(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x38dc
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: parse_unused_keys(xkb_keymap*, Config&, char*)
void parse_unused_keys(xkb_keymap *keymap, Config &config, char *arguments) {
    ArgParser args{arguments};
    while (args.next()) {
        xkb_keycode_t keycode = parse_keycode(keymap, args.value);
        if (keycode < 0) {
            fprintf(stderr,"CONFIG ERROR: unknown unused key: %s \n", args.value);
            exit(1);
        }
        config.unused_keys.push(keycode);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x49a0
leaq 0x10(%rsp), %rdi
callq 0x49d0
testb $0x1, %al
jne 0x3942
jmp 0x3997
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3720
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jae 0x3983
movq 0x6695(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x340f(%rip), %rsi      # 0x6d81
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x3220
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
movl 0xc(%rsp), %esi
callq 0x4b40
jmp 0x3932
addq $0x48, %rsp
retq
nopl (%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: generate_modifier_mapping(_IO_FILE*, char const*, char**)
void generate_modifier_mapping(FILE * file, const char *keyname, char *syms[4]) {
    for(int i = 0; i < 4; i++) {
        if (syms[i] == NULL) return;
        for(auto &mod : ModifierTable) {
            if (strcmp(mod.sym, syms[i]) == 0) {
                fprintf(file, "   modifier_map %s { <%s> };\n", mod.map_name, keyname);
            }
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x4, 0x2c(%rsp)
jge 0x3a81
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x39dc
jmp 0x3a81
leaq 0x6fad(%rip), %rax      # 0xa990
movq %rax, 0x20(%rsp)
leaq 0x6fa1(%rip), %rax      # 0xa990
movq %rax, 0x18(%rsp)
leaq 0x6f95(%rip), %rax      # 0xa990
addq $0xd0, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x3a6f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0x3a5d
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rsp), %rcx
leaq 0x3352(%rip), %rsi      # 0x6da8
movb $0x0, %al
callq 0x3130
jmp 0x3a5f
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x3a06
jmp 0x3a71
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x39bb
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: print_keysyms(_IO_FILE*, char**)
void print_keysyms(FILE * file, char *syms[4]) {
    char *last = NULL;
    if (syms[0] == NULL) return;
    for(int i = 0; i < 4; i++) {
        if (syms[i] != NULL) last = syms[i];
        if (i != 0) {
            fprintf(file, ", ");
        }
        fprintf(file,"%s", last);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x3ab4
jmp 0x3b26
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x3b26
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3ae7
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x3b01
movq 0x20(%rsp), %rdi
leaq 0x32cc(%rip), %rsi      # 0x6dc6
movb $0x0, %al
callq 0x3130
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x32b7(%rip), %rsi      # 0x6dc9
movb $0x0, %al
callq 0x3130
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3abc
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: file_contents(char const*)
char * file_contents( const char *path) {
    int fd = open(path, O_RDONLY);
    if (fd == -1) return NULL;
    int offset = lseek(fd, 0, SEEK_END);
    if (offset < 1) {
        close(fd);
        return NULL;
    }
    lseek(fd, 0, SEEK_SET);
    char * buffer = (char*) malloc(offset + 1);
    if (read(fd, buffer, offset) < (offset - 1)) {
        free(buffer);
        close(fd);
        return NULL;
    }
    buffer[offset] = '\0';
    close(fd);
    return buffer;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x31b0
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x3b60
movq $0x0, 0x20(%rsp)
jmp 0x3c18
movl 0x14(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x30c0
movl %eax, 0x10(%rsp)
cmpl $0x1, 0x10(%rsp)
jge 0x3b94
movl 0x14(%rsp), %edi
callq 0x30f0
movq $0x0, 0x20(%rsp)
jmp 0x3c18
movl 0x14(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30c0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3160
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
movslq 0x10(%rsp), %rdx
callq 0x3100
movl 0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3bf7
movq 0x8(%rsp), %rdi
callq 0x3040
movl 0x14(%rsp), %edi
callq 0x30f0
movq $0x0, 0x20(%rsp)
jmp 0x3c18
movq 0x8(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x14(%rsp), %edi
callq 0x30f0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: install_xkb_rule()
void install_xkb_rule() {
    fprintf(stderr,"Installing custom rule set to ~/.xkb/rules/evdev-doublebind\n");
    if (system("mkdir -p $HOME/.xkb/rules") != 0 ) goto error;
    if (system("cp /usr/share/X11/xkb/rules/evdev.xml $HOME/.xkb/rules/evdev-doublebind.xml")
        != 0) goto error;
    if (system("cp /usr/share/X11/xkb/rules/evdev.lst $HOME/.xkb/rules/evdev-doublebind.lst")
        != 0) goto error;
    if (system("sed 's/!\\s*option\\s*=\\s*symbols/! option	=	symbols\\n\
  evdoublebind:mapping = +evdoublebind(mapping)/g' /usr/share/X11/xkb/rules/evdev\
 > $HOME/.xkb/rules/evdev-doublebind") != 0) goto error;
    return;
error:
    fprintf(stderr,"Failed to install XKB rules set\n");
    exit(1);
}

// Assembly:
pushq %rax
movq 0x63c0(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x318a(%rip), %rsi      # 0x6dcc
movb $0x0, %al
callq 0x3130
leaq 0x31b9(%rip), %rdi      # 0x6e09
callq 0x3080
cmpl $0x0, %eax
je 0x3c5c
jmp 0x3c97
leaq 0x31c0(%rip), %rdi      # 0x6e23
callq 0x3080
cmpl $0x0, %eax
je 0x3c6f
jmp 0x3c97
leaq 0x31f9(%rip), %rdi      # 0x6e6f
callq 0x3080
cmpl $0x0, %eax
je 0x3c82
jmp 0x3c97
leaq 0x3232(%rip), %rdi      # 0x6ebb
callq 0x3080
cmpl $0x0, %eax
je 0x3c95
jmp 0x3c97
popq %rax
retq
movq 0x635a(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x32bd(%rip), %rsi      # 0x6f65
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x3220
nopl (%rax)
// File: exrok[P]evdoublebind/./src/make_config.cc
// Function: ArgParser::next()
bool next() {
        value = NULL;
        if (end == true) return false;
        if (restore != '\0') *c = restore;
        c = skip_ws(c);
        if (*c == '\0') {
            end = true;
            return false;
        }
        value = c;
        while (*c && !(*c == '\t' || *c == ' ')) c++;
        if (*c == '\0') {
            end = true;
            return true;
        }
        restore = *c;
        *c = '\0';
        return true;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x10(%rax)
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a02
movb $0x0, 0x27(%rsp)
jmp 0x4afa
movq 0x10(%rsp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x4a1d
movq 0x10(%rsp), %rax
movb 0x8(%rax), %cl
movq (%rax), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x35f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4a53
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movb $0x0, 0x27(%rsp)
jmp 0x4afa
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, 0xf(%rsp)
je 0x4aa7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, 0xe(%rsp)
je 0x4a9d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4ab1
jmp 0x4ac2
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x4a5f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4ae2
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x4afa
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movb (%rcx), %cl
movb %cl, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Display::write(std::string filename){
	std::ofstream f2(filename, std::ios::binary);
    f2 << "P6" << std::endl;
    f2 << std::to_string(width) << " " << std::to_string(height) << std::endl;
    f2 << "255" << std::endl;
    f2.write((char*)keyboardImage->data, width*height*3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movl $0x4, %edx
callq 0x2370
movq -0x270(%rbp), %rdi
leaq 0x283d(%rip), %rsi      # 0x5091
callq 0x21b0
movq %rax, -0x268(%rbp)
jmp 0x2862
movq -0x268(%rbp), %rdi
movq 0x4738(%rip), %rsi      # 0x6fa8
callq 0x21e0
jmp 0x2877
movq -0x278(%rbp), %rax
movl (%rax), %esi
leaq -0x240(%rbp), %rdi
callq 0x3560
jmp 0x288e
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x21a0
movq %rax, -0x280(%rbp)
jmp 0x28aa
movq -0x280(%rbp), %rdi
leaq 0x27e4(%rip), %rsi      # 0x509c
callq 0x21b0
movq %rax, -0x288(%rbp)
jmp 0x28c6
movq -0x278(%rbp), %rax
movl 0x4(%rax), %esi
leaq -0x260(%rbp), %rdi
callq 0x3560
jmp 0x28de
movq -0x288(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x21a0
movq %rax, -0x290(%rbp)
jmp 0x28fa
movq -0x290(%rbp), %rdi
movq 0x46a0(%rip), %rsi      # 0x6fa8
callq 0x21e0
jmp 0x290f
leaq -0x260(%rbp), %rdi
callq 0x2120
leaq -0x240(%rbp), %rdi
callq 0x2120
leaq 0x2766(%rip), %rsi      # 0x5094
leaq -0x210(%rbp), %rdi
callq 0x21b0
movq %rax, -0x298(%rbp)
jmp 0x2943
movq -0x298(%rbp), %rdi
movq 0x4657(%rip), %rsi      # 0x6fa8
callq 0x21e0
jmp 0x2958
movq -0x278(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x8(%rcx), %rsi
movl (%rax), %ecx
movl 0x4(%rax), %eax
imull %eax, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdx
leaq -0x210(%rbp), %rdi
callq 0x2280
jmp 0x2985
leaq -0x210(%rbp), %rdi
callq 0x22c0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x29ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x29e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x2120
leaq -0x240(%rbp), %rdi
callq 0x2120
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq -0x218(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::set_px(RGB, int, int, int)
void Display::set_px (RGB value, int x, int y, int scale) {
	for(int xscale = 0; xscale < scale; xscale++) {
		for(int yscale=0; yscale < scale; yscale++) {
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].r = value.r;
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].g = value.g;
			keyboardImage->data[keyboardImage->w*(y+yscale) + x+xscale].b = value.b;				
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %esi
movb %sil, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2b08
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2af8
movq -0x30(%rbp), %rdx
movb -0x3(%rbp), %cl
movq 0x30(%rdx), %rax
movq 0x8(%rax), %rax
movq 0x30(%rdx), %rsi
movl (%rsi), %esi
movl -0x18(%rbp), %edi
addl -0x24(%rbp), %edi
imull %edi, %esi
addl -0x14(%rbp), %esi
addl -0x20(%rbp), %esi
movslq %esi, %rsi
imulq $0x3, %rsi, %rsi
addq %rsi, %rax
movb %cl, (%rax)
movb -0x2(%rbp), %cl
movq 0x30(%rdx), %rax
movq 0x8(%rax), %rax
movq 0x30(%rdx), %rsi
movl (%rsi), %esi
movl -0x18(%rbp), %edi
addl -0x24(%rbp), %edi
imull %edi, %esi
addl -0x14(%rbp), %esi
addl -0x20(%rbp), %esi
movslq %esi, %rsi
imulq $0x3, %rsi, %rsi
addq %rsi, %rax
movb %cl, 0x1(%rax)
movb -0x1(%rbp), %cl
movq 0x30(%rdx), %rax
movq 0x8(%rax), %rax
movq 0x30(%rdx), %rdx
movl (%rdx), %edx
movl -0x18(%rbp), %esi
addl -0x24(%rbp), %esi
imull %esi, %edx
addl -0x14(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a54
jmp 0x2afa
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2a41
popq %rbp
retq
nopw (%rax,%rax)