LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1637e
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl %ebp, %r14d
subq %rax, %rcx
je 0x167d4
sarq $0x5, %rcx
decq %rcx
cmpq %r14, %rcx
jae 0x16828
leaq 0xe0c85(%rip), %rdi     # 0xf7460
leaq 0xa4aee(%rip), %rsi     # 0xbb2d0
movl $0x13, %edx
callq 0x80a30
leaq 0xe0c6d(%rip), %rdi     # 0xf7460
movq %r14, %rsi
callq 0x81330
movq %rax, %r14
leaq 0xa882b(%rip), %rsi     # 0xbf030
movl $0x1, %edx
movq %rax, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
jmp 0x16888
movq %r14, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movb $0x4f, (%rax)
leaq 0xe0c23(%rip), %rdi     # 0xf7460
leaq 0xa4aa0(%rip), %rsi     # 0xbb2e4
movl $0x5, %edx
callq 0x80a30
leaq 0xe0c0b(%rip), %rdi     # 0xf7460
movq %r14, %rsi
callq 0x81330
movq %rax, %r14
leaq 0xa4a83(%rip), %rsi     # 0xbb2ea
movl $0xb, %edx
movq %rax, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %r14, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x16dc6
movzbl %bl, %esi
movq %rsp, %rdi
callq 0x16688
movq %rsp, %rdi
callq 0x16d6a
leaq 0x18(%rsp), %rdi
callq 0x16d6a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16d6a
jmp 0x168de
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x16d6a
movq %rbx, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1637e
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl %ebp, %r14d
subq %rax, %rcx
je 0x16924
sarq $0x5, %rcx
decq %rcx
cmpq %r14, %rcx
jae 0x16978
leaq 0xe0b35(%rip), %rdi     # 0xf7460
leaq 0xa499e(%rip), %rsi     # 0xbb2d0
movl $0x13, %edx
callq 0x80a30
leaq 0xe0b1d(%rip), %rdi     # 0xf7460
movq %r14, %rsi
callq 0x81330
movq %rax, %r14
leaq 0xa86db(%rip), %rsi     # 0xbf030
movl $0x1, %edx
movq %rax, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
jmp 0x169eb
movq %r14, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
movq 0x8(%rax,%rcx), %rdx
leaq 0xa490a(%rip), %rcx     # 0xbb299
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x87f80
leaq 0xe0ac0(%rip), %rdi     # 0xf7460
leaq 0xa493d(%rip), %rsi     # 0xbb2e4
movl $0x5, %edx
callq 0x80a30
leaq 0xe0aa8(%rip), %rdi     # 0xf7460
movq %r14, %rsi
callq 0x81330
movq %rax, %r14
leaq 0xa492c(%rip), %rsi     # 0xbb2f6
movl $0x9, %edx
movq %rax, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %r14, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x16dc6
movzbl %bl, %esi
movq %rsp, %rdi
callq 0x16688
movq %rsp, %rdi
callq 0x16d6a
leaq 0x18(%rsp), %rdi
callq 0x16d6a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16d6a
jmp 0x16a41
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x16d6a
movq %rbx, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
movq %rsp, %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1637e
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x16ac9
xorl %r15d, %r15d
leaq 0xa4818(%rip), %r14     # 0xbb299
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x8(%rdi,%r15), %rdx
cmpq $0x3, %rdx
jb 0x16aab
addq %r15, %rdi
movq (%rdi), %rax
cmpb $0x58, (%rax)
je 0x16aab
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x87f80
incl %ebx
incq %r12
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r12, %rax
ja 0x16a86
jmp 0x16acb
xorl %ebx, %ebx
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x16dc6
movzbl %bpl, %esi
leaq 0x18(%rsp), %rdi
callq 0x16688
leaq 0x18(%rsp), %rdi
callq 0x16d6a
leaq 0xe0969(%rip), %rdi     # 0xf7460
leaq 0xa4802(%rip), %rsi     # 0xbb300
movl $0x8, %edx
callq 0x80a30
leaq 0xe0951(%rip), %rdi     # 0xf7460
movl %ebx, %esi
callq 0x81300
movq %rax, %r14
leaq 0xa47e9(%rip), %rsi     # 0xbb309
movl $0xf, %edx
movq %rax, %rdi
callq 0x80a30
xorl %edx, %edx
cmpl $0x2, %ebx
setge %dl
leaq 0xa8600(%rip), %rax     # 0xbf13c
leaq 0xa4756(%rip), %rsi     # 0xbb299
cmovgeq %rax, %rsi
movq %r14, %rdi
callq 0x80a30
leaq 0xa47c3(%rip), %rsi     # 0xbb319
movl $0xf, %edx
movq %r14, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %r14, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %rsp, %rdi
callq 0x16d6a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x16d6a
jmp 0x16bb3
jmp 0x16bb0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16d6a
movq %rbx, %rdi
callq 0xb8350
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
movq %rsp, %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1637e
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x16c31
xorl %r15d, %r15d
leaq 0xa46a8(%rip), %r14     # 0xbb299
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x8(%rdi,%r15), %rdx
cmpq $0x3, %rdx
jb 0x16c13
addq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x87f80
incl %ebx
incq %r12
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r12, %rax
ja 0x16bf6
jmp 0x16c33
xorl %ebx, %ebx
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x16dc6
movzbl %bpl, %esi
leaq 0x18(%rsp), %rdi
callq 0x16688
leaq 0x18(%rsp), %rdi
callq 0x16d6a
leaq 0xe0801(%rip), %rdi     # 0xf7460
leaq 0xa46c3(%rip), %rsi     # 0xbb329
movl $0x8, %edx
callq 0x80a30
leaq 0xe07e9(%rip), %rdi     # 0xf7460
movl %ebx, %esi
callq 0x81300
movq %rax, %r14
leaq 0xa468b(%rip), %rsi     # 0xbb313
movl $0x5, %edx
movq %rax, %rdi
callq 0x80a30
xorl %edx, %edx
cmpl $0x2, %ebx
setge %dl
leaq 0xa8498(%rip), %rax     # 0xbf13c
leaq 0xa45ee(%rip), %rsi     # 0xbb299
cmovgeq %rax, %rsi
movq %r14, %rdi
callq 0x80a30
leaq 0xa4674(%rip), %rsi     # 0xbb332
movl $0xf, %edx
movq %r14, %rdi
callq 0x80a30
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61b80
movsbl %al, %esi
movq %r14, %rdi
callq 0x80530
movq %rax, %rdi
callq 0x7fb00
movq %rsp, %rdi
callq 0x16d6a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x16d6a
jmp 0x16d1b
jmp 0x16d18
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16d6a
movq %rbx, %rdi
callq 0xb8350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq 0x5d90(%rip), %rbx      # 0x8ff8
movq (%rbx), %rcx
leaq 0x2a1c(%rip), %rdi      # 0x5c8e
pushq $0x3c
popq %rsi
pushq $0x1
popq %rdx
callq 0x3240
leaq 0x2a47(%rip), %rdi      # 0x5ccb
callq 0x3080
testl %eax, %eax
jne 0x32bf
leaq 0x2a51(%rip), %rdi      # 0x5ce5
callq 0x3080
testl %eax, %eax
jne 0x32bf
leaq 0x2a8d(%rip), %rdi      # 0x5d31
callq 0x3080
testl %eax, %eax
jne 0x32bf
leaq 0x2ac9(%rip), %rdi      # 0x5d7d
callq 0x3080
testl %eax, %eax
jne 0x32bf
popq %rbx
retq
movq (%rbx), %rcx
leaq 0x2b5e(%rip), %rdi      # 0x5e27
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x3240
pushq $0x1
popq %rdi
callq 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
xorl %ebx, %ebx
movb %bl, 0x8(%r12)
movq $0x0, 0x10(%r12)
movb %bl, 0x18(%r12)
movl $0x20, %r15d
movq %r12, %rdi
callq 0x4490
testb %al, %al
je 0x3846
cmpb $0x0, 0x20(%rsp)
jne 0x382d
movb $0x0, 0x10(%rsp)
incq 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%r14,%rbx,8)
incq %rbx
addq $-0x8, %r15
jne 0x3810
movl $0x4, %ebx
jmp 0x385a
cmpq $0x4, %rbx
jae 0x385a
leaq (%r14,%rbx,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x30e0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x38c4
movq %rsi, %rbx
cmpb $0x3c, (%rsi)
jne 0x38b7
movq %rdi, %r14
incq %rbx
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x3090
testq %rax, %rax
je 0x38c4
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30b0
cmpl $0x8, %eax
jl 0x38d1
movl %eax, %ebp
movb $0x3e, (%r15)
jmp 0x38c4
movq %rbx, %rdi
callq 0x3220
movl %eax, %ebp
addl $0x8, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3317
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq %rsp, %rdi
movq %rcx, (%rdi)
xorl %r12d, %r12d
movb %r12b, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb %r12b, 0x18(%rdi)
callq 0x4490
testb %al, %al
je 0x393b
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3868
cmpq $0x2, %r12
je 0x3961
movl %eax, (%rbx,%r12,4)
incq %r12
movq %r15, %rdi
callq 0x4490
testb %al, %al
jne 0x3915
cmpl $0x1, %r12d
ja 0x3954
movl %r12d, %eax
movl $0xffffffff, (%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq $0x1, %rax
je 0x3944
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x333b
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movq %rdx, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb %al, 0x18(%rdi)
callq 0x4490
testb %al, %al
je 0x39d4
leaq 0x20(%rbx), %r15
movq %rsp, %r12
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3868
movl %eax, %ebp
movq %r15, %rdi
callq 0x460a
movq 0x20(%rbx), %rax
movslq 0x2c(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rbx)
movl %ebp, (%rax,%rcx,4)
movq %r12, %rdi
callq 0x4490
testb %al, %al
jne 0x39a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5fa4(%rip), %r13      # 0x99a0
xorl %ebp, %ebp
cmpq $0x0, (%rbx,%rbp,8)
je 0x3a4b
movl $0x8, %r12d
movq -0x8(%r12,%r13), %rdi
movq (%rbx,%rbp,8), %rsi
callq 0x3140
testl %eax, %eax
jne 0x3a35
movq (%r12,%r13), %rdx
movq %r15, %rdi
leaq 0x2242(%rip), %rsi      # 0x5c6d
movq %r14, %rcx
xorl %eax, %eax
callq 0x3150
addq $0x10, %r12
cmpq $0xd8, %r12
jne 0x3a0b
incq %rbp
cmpq $0x4, %rbp
jne 0x39fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, (%rsi)
je 0x3abe
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x2212(%rip), %r15      # 0x5c8b
xorl %r12d, %r12d
movq (%rbx,%r13,8), %rax
testq %rax, %rax
cmovneq %rax, %r12
testq %r13, %r13
je 0x3aa1
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3240
movq %r12, %rdi
movq %r14, %rsi
callq 0x30d0
incq %r13
cmpq $0x4, %r13
jne 0x3a7c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x31c0
cmpl $-0x1, %eax
je 0x3b42
movl %eax, %ebx
xorl %r14d, %r14d
movl %eax, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x30c0
movq %rax, %r15
testl %r15d, %r15d
jle 0x3b3b
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x30c0
leal 0x1(%r15), %edi
callq 0x3170
movq %rax, %r14
movl %r15d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl %ebx, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x3120
decl %r15d
cmpq %r15, %rax
jge 0x3b36
movq %r14, %rdi
callq 0x3040
xorl %r14d, %r14d
jmp 0x3b3b
movb $0x0, (%r14,%r12)
movl %ebx, %edi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrok[P]evdoublebind/./src/make_config.cc
// Function: parse_arguments(Settings&&, int, char**)
Settings parse_arguments(Settings &&setting, int argc, char **argv){
    opterr = 0;
    optind = 0;
    char *cvalue = NULL;
    int c;
    bool suppress_no_input_error = false;
    while ((c = getopt (argc, argv, "gahr:m:l:v:o:x:c:")) != -1)
        switch(c){
            case 'g':
                install_xkb_rule();
                suppress_no_input_error = true;
                continue;
            case 'a':
                setting.only_arguments = true;
                continue;
            case 'h':
                print_usage();
                exit(0);
            case 'l':
                setting.xkb_names.layout = optarg;
                continue;
            case 'm':
                setting.xkb_names.model = optarg;
                continue;
            case 'r':
                setting.xkb_names.rules = optarg;
                continue;
            case 'o':
                setting.xkb_names.options = optarg;
                continue;
            case 'v':
                setting.xkb_names.variant = optarg;
                continue;
            case 'x':
                setting.xkb_conf_output = optarg;
                continue;
            case 'c':
                setting.evdoublebind_conf_output = optarg;
                continue;
        }
    if (argc - optind < 1) {
        if (suppress_no_input_error) {
            exit(0);
        } else {
            fprintf(stderr, "No config specfied\n");
            print_usage();
            exit(1);
        }
    }
    setting.input_conf = argv[optind];
    return setting;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x4ca3(%rip), %rax      # 0x8ff0
xorl %ecx, %ecx
movl %ecx, (%rax)
movq 0x4c70(%rip), %rax      # 0x8fc8
movl $0x0, 0xc(%rsp)
movl %ecx, (%rax)
leaq 0x23d9(%rip), %r12      # 0x6742
leaq 0xc94(%rip), %rbx       # 0x5004
movq 0x4c59(%rip), %r13      # 0x8fd0
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3200
leal -0x61(%rax), %ecx
cmpl $0x17, %ecx
ja 0x43e1
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
movb $0x1, 0x28(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x18(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x8(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x20(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x40(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x10(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, 0x38(%r14)
jmp 0x4377
movq (%r13), %rax
movq %rax, (%r14)
jmp 0x4377
cmpl $-0x1, %eax
jne 0x4377
jmp 0x43f5
callq 0x3260
movb $0x1, %al
movl %eax, 0xc(%rsp)
jmp 0x4377
movq 0x4bcc(%rip), %rax      # 0x8fc8
movslq (%rax), %rax
cmpl %ebp, %eax
jge 0x4439
movq (%r15,%rax,8), %rax
movq %rax, 0x30(%r14)
movl $0x9, %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x431f
xorl %edi, %edi
callq 0x3230
testb $0x1, 0xc(%rsp)
jne 0x4432
callq 0x3521
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq $0x0, 0x10(%rdi)
cmpb $0x0, 0x18(%rdi)
jne 0x44f5
movb 0x8(%rdi), %al
testb %al, %al
je 0x44aa
movq (%rdi), %rcx
movb %al, (%rcx)
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x44ba
cmpl $0x9, %ecx
jne 0x44bf
incq %rax
jmp 0x44ad
movq %rax, (%rdi)
cmpb $0x0, (%rax)
je 0x44f1
movq %rax, 0x10(%rdi)
movq (%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x44f8
cmpl $0x9, %ecx
je 0x44e8
cmpl $0x20, %ecx
je 0x44e8
movq %rax, (%rdi)
jmp 0x44ce
movb %cl, 0x8(%rdi)
movb $0x0, -0x1(%rax)
jmp 0x44fc
movb $0x1, 0x18(%rdi)
xorl %eax, %eax
retq
movb $0x1, 0x18(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/exrok[P]evdoublebind/./src/make_config.cc
// Function: ConfigParser::next()
bool next() {
        key = value = NULL;
        while (!end) {
            char *last; //last character in ident
            char *ident; //current token either value or key depending on state
            int state = 0;
            ident = last = c = skip_ws(c);
            while (1) {
                switch (*c) {
                    case ':':
                        if (state == 0) {
                            *(last+1) = '\0';
                            state = 1;
                            key = ident;
                            ident = c = skip_ws(c+1);
                            continue;
                        } else {
                            fprintf(stderr,"ERROR: unexpected ':' on line %d\n'", line + 1);
                            exit(1);
                        }
                        break;
                    case ' ': //Skip White Space
                    case '\t':
                        last = c-1;
                        c = skip_ws(c + 1);
                        continue;
                    case '#': //Skip Comment
                        c++;
                        while (*c && *c != '\n' ) c++; //Fallthougth
                    case '\n':
                    case '\0':
                        goto end_line;
                }
                last = c++;
            }
        end_line:
            line++;
            end = (*c == '\0');
            if (state == 1 && last != ident) {
                *(last+1) = '\0';
                value = ident;
                c++;
                return true;
            }
            c++;
        }
        return false;
    }

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movb 0x1c(%rdi), %al
testb %al, %al
jne 0x45fe
movq (%rdi), %r9
movzbl (%r9), %ecx
cmpl $0x9, %ecx
je 0x4524
cmpl $0x20, %ecx
jne 0x4529
incq %r9
jmp 0x4516
xorl %edx, %edx
movq %r9, %rsi
movq %r9, %rcx
movq %r9, (%rdi)
movq (%rdi), %r8
movzbl (%r8), %r9d
cmpl $0x3a, %r9d
jne 0x456e
testl %edx, %edx
jne 0x4604
movb $0x0, 0x1(%rsi)
movq %rcx, 0x8(%rdi)
movq (%rdi), %rcx
incq %rcx
movzbl (%rcx), %edx
cmpl $0x20, %edx
je 0x4554
cmpl $0x9, %edx
je 0x4554
movq %rcx, (%rdi)
movl $0x1, %edx
jmp 0x4534
cmpl $0x9, %r9d
jle 0x459d
cmpl $0xa, %r9d
je 0x45d4
cmpl $0x23, %r9d
je 0x45bc
cmpl $0x20, %r9d
jne 0x45a8
leaq 0x1(%r8), %r9
movzbl (%r9), %esi
cmpl $0x20, %esi
je 0x4598
cmpl $0x9, %esi
jne 0x45b1
incq %r9
jmp 0x458a
testl %r9d, %r9d
je 0x45d4
cmpl $0x9, %r9d
je 0x4586
leaq 0x1(%r8), %r9
movq %r8, %rsi
jmp 0x4531
decq %r8
movq %r8, %rsi
jmp 0x4531
incq %r8
movq %r8, (%rdi)
movzbl (%r8), %r9d
testl %r9d, %r9d
je 0x45d4
incq %r8
cmpl $0xa, %r9d
jne 0x45bf
incl 0x18(%rdi)
movq (%rdi), %r8
cmpb $0x0, (%r8)
sete 0x1c(%rdi)
testl %edx, %edx
je 0x45eb
cmpq %rcx, %rsi
jne 0x45f3
incq (%rdi)
jmp 0x4508
movb $0x0, 0x1(%rsi)
movq %rcx, 0x10(%rdi)
incq (%rdi)
notb %al
andb $0x1, %al
popq %rcx
retq
callq 0x34f8
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/predict.c
// Function: main
int main(int argc, char **argv)
{
	FILE *input, *output;
	int i;

	// parse options
	for(i=1;i<argc;i++)
	{
		if(argv[i][0] != '-') break;
		++i;
		switch(argv[i-1][1])
		{
			case 'b':
				flag_predict_probability = atoi(argv[i]);
				break;
			case 'q':
				info = &print_null;
				i--;
				break;
			default:
				fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
				exit_with_help();
				break;
		}
	}
	if(i>=argc)
		exit_with_help();

	input = fopen(argv[i],"r");
	if(input == NULL)
	{
		fprintf(stderr,"can't open input file %s\n",argv[i]);
		exit(1);
	}

	output = fopen(argv[i+2],"w");
	if(output == NULL)
	{
		fprintf(stderr,"can't open output file %s\n",argv[i+2]);
		exit(1);
	}

	if((model_=load_model(argv[i+1]))==0)
	{
		fprintf(stderr,"can't open model file %s\n",argv[i+1]);
		exit(1);
	}

	x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node));
	do_predict(input, output);
	free_and_destroy_model(&model_);
	free(line);
	free(x);
	fclose(input);
	fclose(output);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
setge %al
jl 0x30d7
movq %rsi, %rbx
movq 0x8(%rsi), %rdx
movl $0x1, %ecx
cmpb $0x2d, (%rdx)
jne 0x3018
movl %edi, %ebp
movl $0x1, %r14d
leaq -0x6f0(%rip), %r15      # 0x28dc
movzbl 0x1(%rdx), %eax
cmpl $0x71, %eax
je 0x2ff6
cmpl $0x62, %eax
jne 0x30ed
movslq %r14d, %rax
incl %r14d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x21f0
movl %eax, 0xe1b4(%rip)      # 0x111a8
jmp 0x2ffd
movq %r15, 0xe173(%rip)      # 0x11170
incl %r14d
cmpl %ebp, %r14d
setl %al
jge 0x30d7
movslq %r14d, %rcx
movq (%rbx,%rcx,8), %rdx
cmpb $0x2d, (%rdx)
je 0x2fcc
testb %al, %al
je 0x30d7
leaq (%rbx,%rcx,8), %r15
movq (%r15), %rdi
leaq 0xa0e6(%rip), %rsi      # 0xd114
callq 0x2150
testq %rax, %rax
je 0x30f5
movq %rax, %rbx
movq 0x10(%r15), %rdi
leaq 0xa0e6(%rip), %rsi      # 0xd130
callq 0x2150
testq %rax, %rax
je 0x30fd
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0xa590
movq %rax, 0xe135(%rip)      # 0x111a0
testq %rax, %rax
je 0x3109
movslq 0xe0ed(%rip), %rdi      # 0x11168
shlq $0x4, %rdi
callq 0x21a0
movq %rax, 0xe10d(%rip)      # 0x11198
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2904
leaq 0xe103(%rip), %rdi      # 0x111a0
callq 0x95cb
movq 0xe107(%rip), %rdi      # 0x111b0
callq 0x2160
movq 0xe0e3(%rip), %rdi      # 0x11198
callq 0x2160
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa089(%rip), %rdi      # 0xd167
callq 0x21e0
movl $0x1, %edi
callq 0x2170
movzbl %al, %edi
callq 0x23ee
movq %r15, %rdi
callq 0x23c7
addq $0x10, %r15
movq %r15, %rdi
callq 0x23a0
addq $0x8, %r15
movq %r15, %rdi
callq 0x2379
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %r8d, %r8d
jle 0x29d7
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
shrl $0x8, %eax
movl %esi, %r9d
shrl $0x10, %r9d
movq 0x30(%rdi), %r10
movq 0x8(%r10), %rdi
movl (%r10), %r10d
movl %r8d, %r11d
imull %r10d, %ecx
addl %ecx, %edx
xorl %ecx, %ecx
movq %r11, %rbx
movl %edx, %r14d
movslq %r14d, %r14
leaq (%r14,%r14,2), %r15
movb %sil, (%rdi,%r15)
movb %al, 0x1(%rdi,%r15)
movb %r9b, 0x2(%rdi,%r15)
addl %r10d, %r14d
decq %rbx
jne 0x29ac
incl %ecx
incl %edx
cmpl %r8d, %ecx
jne 0x29a6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::print_letter(char, int, int, int, bool)
void Display::print_letter(char letter, int atX, int atY, int scale, bool inverted) {
	RGB white = {0xFF, 0xFF, 0xFF};
	RGB black = {0x10, 0x10, 0x10};
	for (int y=0; y < 8; y++) {
		for (int x = 0; x < 8; x++) {
			if(font8x8_basic[(uint8_t) letter][x] & (uint8_t)(1 << (7-(y)))) {
				set_px(inverted ? black : white, atX + (x*scale), atY + (y*scale), scale);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, 0x20(%rsp)
decl %r9d
orl $0x101010, %r9d         # imm = 0x101010
movl %r9d, 0x14(%rsp)
movzbl %sil, %r14d
shll $0x3, %r14d
xorl %eax, %eax
movb $0x7, %cl
subb %al, %cl
movl $0x1, %ebx
shll %cl, %ebx
movq %rax, 0x18(%rsp)
movl %eax, %r13d
imull %ebp, %r13d
addl 0x10(%rsp), %r13d
movl 0xc(%rsp), %r15d
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
leaq 0x3732(%rip), %rcx      # 0x6170
movzbl (%rcx,%rax), %eax
testl %eax, %ebx
je 0x2a5d
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x297a
incq %r12
addl %ebp, %r15d
cmpq $0x8, %r12
jne 0x2a33
movq 0x18(%rsp), %rax
incl %eax
cmpl $0x8, %eax
jne 0x2a0f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::fastRect(int, int, int, int, RGB)
void Display::fastRect(int atX, int atY, int width, int height, RGB color) {
	for(int y = 0; y < height; y++) {
		for(int x = 0; x < width; x++) {
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].r = color.r;
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].g = color.g;
			keyboardImage->data[((atY+y)*keyboardImage->w) + (atX + x)].b = color.b;
		}
	}
}

// Assembly:
testl %r8d, %r8d
jle 0x2af7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %eax
shrl $0x8, %eax
movl %r9d, %r10d
shrl $0x10, %r10d
movq 0x30(%rdi), %rdi
movslq %esi, %rsi
movl %ecx, %r11d
leaq (%r11,%r11,2), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x2ae7
movq 0x8(%rdi), %r14
movslq (%rdi), %r15
movslq %edx, %r12
imulq %r15, %r12
addq %rsi, %r12
leaq (%r12,%r12,2), %r15
addq %r15, %r14
addq $0x2, %r14
xorl %r15d, %r15d
movb %r9b, -0x2(%r14,%r15)
movb %al, -0x1(%r14,%r15)
movb %r10b, (%r14,%r15)
addq $0x3, %r15
cmpq %r15, %r11
jne 0x2ad0
incl %ebx
incl %edx
cmpl %r8d, %ebx
jne 0x2aad
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::xLine(int, int, RGB)
void Display::xLine(int startX, int y, RGB color) {
	for(int x = startX; x < keyboardImage->w; x++) {
		keyboardImage->data[((y)*keyboardImage->w) + x].r = color.r;
		keyboardImage->data[((y)*keyboardImage->w) + x].g = color.g;
		keyboardImage->data[((y)*keyboardImage->w) + x].b = color.b;
	}
}

// Assembly:
movq 0x30(%rdi), %r9
movslq (%r9), %rax
cmpl %esi, %eax
jle 0x2b40
movl %ecx, %edi
shrl $0x8, %edi
movl %ecx, %r8d
shrl $0x10, %r8d
movq 0x8(%r9), %r9
imull %eax, %edx
movslq %esi, %rsi
movslq %edx, %rdx
addq %rsi, %rdx
leaq (%rdx,%rdx,2), %rdx
addq %r9, %rdx
addq $0x2, %rdx
subq %rsi, %rax
movb %cl, -0x2(%rdx)
movb %dil, -0x1(%rdx)
movb %r8b, (%rdx)
addq $0x3, %rdx
decq %rax
jne 0x2b2d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/magmastonealex[P]fbkeyboard/src/Display.cpp
// Function: Display::yLine(int, int, RGB)
void Display::yLine(int x, int startY, RGB color) {
	for(int y = startY; y < keyboardImage->h; y++) {
		keyboardImage->data[((y)*keyboardImage->w) + x].r = color.r;
		keyboardImage->data[((y)*keyboardImage->w) + x].g = color.g;
		keyboardImage->data[((y)*keyboardImage->w) + x].b = color.b;
	}
}

// Assembly:
movq 0x30(%rdi), %r9
movslq 0x4(%r9), %rax
cmpl %edx, %eax
jle 0x2b92
movl %ecx, %edi
shrl $0x8, %edi
movl %ecx, %r8d
shrl $0x10, %r8d
movq 0x8(%r9), %r10
movslq (%r9), %r9
movslq %edx, %r11
movslq %esi, %rsi
leaq (%r9,%r9,2), %rdx
imulq %r11, %r9
addq %rsi, %r9
leaq (%r9,%r9,2), %rsi
addq %r10, %rsi
addq $0x2, %rsi
subq %r11, %rax
movb %cl, -0x2(%rsi)
movb %dil, -0x1(%rsi)
movb %r8b, (%rsi)
addq %rdx, %rsi
decq %rax
jne 0x2b80
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/magmastonealex[P]fbkeyboard/src/Input.cpp
// Function: Input::getNextEvent()
Touch Input::getNextEvent() {
	inputEvent event;
	eventStream.read((char*)&event, sizeof(event));
	int keepLooping = 1;
	int touchX;
	int touchY;
	int isDown = 0;
	while(isDown == 0) {
		while(keepLooping) {
			if(event.code == 57 && ((int)event.value != -1)) {
				isDown = 1;
			}
			if(event.code == 0x35) {
				touchX = event.value;
			}
			if(event.code == 0x36) {
				touchY = event.value;
			}
			eventStream.read((char*)&event, sizeof(event));
			if(event.type == 0 && event.code == 0 && event.value == 0) {
				keepLooping = 0;
			}
		}
		keepLooping = 1;
	}
	return Touch(touchX, touchY);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x18, %edx
movq %r14, %rsi
callq 0x21f0
xorl %r13d, %r13d
movl $0x1, %r12d
movl %r13d, %eax
movl 0x14(%rsp), %ecx
cmpl $-0x1, %ecx
cmovnel %r12d, %r13d
movzwl 0x12(%rsp), %edx
cmpw $0x39, %dx
cmovnel %eax, %r13d
cmpw $0x35, %dx
cmovel %ecx, %ebp
cmpw $0x36, %dx
cmovel %ecx, %r15d
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
cmpw $0x0, 0x10(%rsp)
jne 0x3176
cmpw $0x0, 0x12(%rsp)
jne 0x3176
cmpl $0x0, 0x14(%rsp)
jne 0x3176
testl %r13d, %r13d
movl $0x0, %r13d
je 0x3176
shlq $0x20, %r15
movl %ebp, %eax
orq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::LongNumber(LongNumber const&)
LongNumber::LongNumber(const LongNumber& X) {
	//equating the two vectors
	digits = X.digits;

	//equating the booleans
	negative = X.negative;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x551e
movb 0x18(%r14), %al
movb %al, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x285e
callq 0x20b0
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::absolute()
LongNumber LongNumber::absolute() {
	LongNumber ans;

	ans.digits = digits;
	ans.negative = false;

	return ans;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x27ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x551e
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2d17
callq 0x20b0
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: operator>>(std::istream&, LongNumber&)
std::istream& operator>>(std::istream& input, LongNumber& X) {
	std::string number;
	input >> number;
	X = number;

	return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rsi
callq 0x2110
movq %rsp, %rsi
movq %r14, %rdi
callq 0x28a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d64
callq 0x20b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d82
callq 0x20b0
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: operator<<(std::ostream&, LongNumber const&)
std::ostream& operator<<(std::ostream& output, const LongNumber& X) {
	std::string printed;
	if (X.negative) {
		output << "-";
	}

	output << *(X.digits.end()-1);

	for(int i = X.digits.size() - 2; i >= 0; i--) {
		printed = std::to_string(X.digits[i]);
		while(printed.length() < 9) {
			printed = "0" + printed;
		}
		output << printed;
	}

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpb $0x1, 0x18(%rsi)
jne 0x2dcc
leaq 0x32d1(%rip), %rsi      # 0x6090
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20e0
movq 0x8(%r14), %rax
movl -0x4(%rax), %esi
movq %rbx, %rdi
callq 0x2160
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
addl $-0x2, %eax
js 0x2f22
leaq 0x48(%rsp), %r13
movl %eax, %edx
leaq 0x38(%rsp), %r15
movq %rsp, %r12
movl $0xd1b71759, %esi       # imm = 0xD1B71759
movq %rbx, 0x28(%rsp)
movq %r14, 0x20(%rsp)
movq (%r14), %rax
movl (%rax,%rdx,4), %ebp
movl %ebp, %ebx
negl %ebx
cmovsl %ebp, %ebx
movl $0x1, %r14d
cmpl $0xa, %ebx
jb 0x2e66
movl $0x4, %r14d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0x2e5d
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x2e63
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x2e66
movl %eax, %ecx
imulq %rsi, %rcx
shrq $0x2d, %rcx
addl $0x4, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x2e2d
addl $-0x3, %r14d
jmp 0x2e66
addl $-0x2, %r14d
jmp 0x2e66
decl %r14d
movq %rdx, 0x30(%rsp)
shrl $0x1f, %ebp
leal (%r14,%rbp), %esi
movq %r13, 0x38(%rsp)
movq %r15, %rdi
movl $0x2d, %edx
callq 0x20f0
addq 0x38(%rsp), %rbp
movq %rbp, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x56a8
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x2eb0
callq 0x20b0
movq 0x8(%rsp), %rdx
cmpq $0x8, %rdx
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %r14
leaq 0x31e1(%rip), %rbp      # 0x60ab
ja 0x2eff
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x55ec
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ef4
callq 0x20b0
movq 0x8(%rsp), %rdx
cmpq $0x9, %rdx
jb 0x2ecc
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
movq 0x30(%rsp), %rcx
leaq -0x1(%rcx), %rdx
testq %rcx, %rcx
movl $0xd1b71759, %esi       # imm = 0xD1B71759
jg 0x2e0d
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2f35
callq 0x20b0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f4f
jmp 0x2f4f
jmp 0x2f4f
jmp 0x2f4f
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2f65
callq 0x20b0
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator<(LongNumber const&)
bool LongNumber::operator<(const LongNumber& X) {
	if (!negative) {
		if (X.negative) {
			return false;
		}

		else {
			if (digits.size() > X.digits.size()) {
				return false;
			} else if (digits.size() == X.digits.size()) {
				for (int i = digits.size() - 1; i >= 0; i--) {
					if (digits[i] < X.digits[i]) {
						return true;
					} else if(digits[i] > X.digits[i]){
						return false;
					}
				}

				return false;
			} else {
				return true;
			}
		}
	}

	else {
		if (!X.negative) {
			return true;
		}

		else {
			if (digits.size() > X.digits.size()) {
				return true;
			} else if (digits.size() == X.digits.size()) {
				for (int i = digits.size() - 1; i >= 0; i--) {
					if (digits[i] > X.digits[i]) {
						return true;
					} else if (digits[i] < X.digits[i]) {
						return false;
					}
				}

				return false;
			} else {
				return false;
			}
		}
	}
}

// Assembly:
movb 0x18(%rsi), %cl
cmpb $0x0, 0x18(%rdi)
je 0x2fd3
movb $0x1, %al
testb %cl, %cl
je 0x2ffa
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rsi, %rdi
ja 0x2ffa
jne 0x2ff8
movl %edi, %esi
decq %rsi
movq %rsi, %rax
testl %eax, %eax
js 0x3033
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
movl (%rcx,%rsi), %edi
movl (%rdx,%rsi), %r8d
cmpl %r8d, %edi
jg 0x3030
leaq -0x1(%rax), %rsi
cmpl %r8d, %edi
jge 0x2fa5
jmp 0x302c
testb %cl, %cl
jne 0x2ff8
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
subq %rdx, %rax
sarq $0x2, %rax
cmpq %rax, %rdi
jbe 0x2ffb
xorl %eax, %eax
retq
movb $0x1, %al
jne 0x2ffa
movl %edi, %esi
decq %rsi
movq %rsi, %rax
testl %eax, %eax
js 0x3033
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
movl (%rcx,%rsi), %edi
movl (%rdx,%rsi), %r8d
cmpl %r8d, %edi
jl 0x3030
leaq -0x1(%rax), %rsi
cmpl %r8d, %edi
jle 0x3004
xorl %esi, %esi
jmp 0x3033
movb $0x1, %sil
testl %eax, %eax
setns %al
andb %sil, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator*(long)
LongNumber LongNumber::operator*(long int X) {
	if(X == 0) {
		return LongNumber();
	} else {
	LongNumber answer;
	long int product = 0, carry = 0;
	answer.digits.erase(answer.digits.begin(), answer.digits.end());

	for(int i = 0; i < digits.size(); i++) {
		product = X * (digits)[i] + carry;
		carry = product / BASE;
		product = product % BASE;
		answer.digits.push_back(product);
	}
	while (carry > 0) {
		answer.digits.push_back(carry % BASE);
		carry /= BASE;
	}

	return answer;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x27ac
testq %r15, %r15
je 0x476f
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x46ac
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x46ac
movq %rax, 0x8(%rbx)
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x471a
xorl %ebp, %ebp
leaq 0x4(%rsp), %r13
xorl %r14d, %r14d
movslq (%rax,%rbp,4), %rax
imulq %r15, %rax
addq %r14, %rax
movslq 0x4a15(%rip), %rcx      # 0x90e8
cqto
idivq %rcx
movl %edx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %r14
cmpq 0x10(%rbx), %rsi
je 0x46f5
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4700
movq %rbx, %rdi
movq %r13, %rdx
callq 0x57c4
incq %rbp
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x46c1
jmp 0x471d
xorl %r14d, %r14d
testq %r14, %r14
jle 0x476f
movq %rsp, %r15
movslq 0x49bc(%rip), %rcx      # 0x90e8
movq %r14, %rax
cqto
idivq %rcx
movl %edx, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x474d
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4758
movq %rbx, %rdi
movq %r15, %rdx
callq 0x57c4
movslq 0x4989(%rip), %rcx      # 0x90e8
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %r14
testq %rax, %rax
jg 0x4725
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4783
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4793
callq 0x20b0
movq %r14, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O1/aadityanaik[P]LongNums/src/longnums.cpp
// Function: LongNumber::operator%(LongNumber)
LongNumber LongNumber::operator%(LongNumber X) {
	LongNumber quotient;
	LongNumber remainder;

	quotient = (*this) / X;
	
	remainder = (*this) - (X * quotient);

	return remainder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27ac
movq %rbx, %rdi
callq 0x27ac
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x2822
movq %rsp, %rdi
leaq 0x80(%rsp), %rdx
movq %r14, %rsi
callq 0x479c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x551e
movb 0x18(%rsp), %al
movb %al, 0x38(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f99
callq 0x20b0
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x4fab
callq 0x20b0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2822
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r15, %rsi
callq 0x37ac
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
movq %r14, %rsi
callq 0x3402
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x551e
movb 0x18(%rsp), %al
movb %al, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4ffc
callq 0x20b0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x500b
callq 0x20b0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x501a
callq 0x20b0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5029
callq 0x20b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x504f
callq 0x20b0
jmp 0x504f
movq %rax, %r14
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x5063
callq 0x20b0
jmp 0x5063
movq %rax, %r14
movq 0x40(%rsp), %rdi
jmp 0x508a
jmp 0x5096
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5082
callq 0x20b0
jmp 0x5082
movq %rax, %r14
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x5099
callq 0x20b0
jmp 0x5099
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x50ab
callq 0x20b0
jmp 0x50ab
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x50ba
callq 0x20b0
movq %r14, %rdi
callq 0x2180