LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/input_event_names.h
// Function: evout(input_event const&)
void evout(const input_event &e){
   if (e.type == EV_KEY){
       fprintf(stdout,"EV_KEY(%s:%d, %s:%d)\n",
              key_code_name(e.code), e.code,
              key_state_name(e.value), e.value);
   }else if (e.type == EV_MSC){
       fprintf(stdout,"EV_MSC(%s:%d, %d)\n",
              msc_code_name(e.code), e.code,
              e.value);
   }else if (e.type == EV_SYN){
       fprintf(stdout,"EV_SYN~%s:%d\n",
              syn_code_name(e.code),e.value);
   }
   else{
       fprintf(stderr,"%s\n", ev_code_name(e.type));
   }
}

// Assembly:
movzwl 0x10(%rdi), %eax
testl %eax, %eax
je 0x34bd
cmpl $0x4, %eax
je 0x34de
cmpl $0x1, %eax
jne 0x354e
movq 0x3b38(%rip), %rax      # 0x6fb8
movzwl 0x12(%rdi), %ecx
cmpl $0xf8, %ecx
leaq 0x3d0f(%rip), %rdx      # 0x71a0
leaq (%rdx,%rcx,8), %rdx
leaq 0x3cfc(%rip), %rsi      # 0x7198
cmovbq %rdx, %rsi
movq (%rax), %rax
movq (%rsi), %rdx
movl 0x14(%rdi), %r9d
cmpq $0x2, %r9
ja 0x34ff
leaq 0x38e9(%rip), %rsi      # 0x6da0
movq (%rsi,%r9,8), %r8
jmp 0x3506
movq 0x3af4(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x3, %rcx
ja 0x3517
leaq 0x3c98(%rip), %rdx      # 0x7170
movq (%rdx,%rcx,8), %rdx
jmp 0x351e
movq 0x3ad3(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x6, %rcx
ja 0x3532
leaq 0x4467(%rip), %rdx      # 0x7960
movq (%rdx,%rcx,8), %rdx
jmp 0x3539
leaq 0x1607(%rip), %r8       # 0x4b0d
leaq 0x161f(%rip), %rsi      # 0x4b2c
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x1602(%rip), %rdx      # 0x4b20
movl 0x14(%rdi), %ecx
leaq 0x162d(%rip), %rsi      # 0x4b55
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x15db(%rip), %rdx      # 0x4b14
movl 0x14(%rdi), %r8d
leaq 0x15fe(%rip), %rsi      # 0x4b42
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
pushq %rax
movl %eax, %edi
callq 0x3260
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/inspector.cc
// Function: is_keyboard(int)
int is_keyboard(int fd) {
    errno = 0;
    u_int64_t evbitset = 0;
    u_int64_t keybits[4] = {0};
    ioctl(fd, EVIOCGBIT(0, sizeof(evbitset)), &evbitset);
    if (errno) return 0;
    if (!(evbitset & (1ul << EV_KEY))) {
        return 0;
    }

    errno = 0;
    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
    if (errno)
        return 0;

    if (keybits[0] | keybits[1] | keybits[2] | keybits[3]) {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebp
movl $0x80084520, %r15d      # imm = 0x80084520
callq 0x3050
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
movdqa %xmm0, 0x10(%rsp)
xorl %ebx, %ebx
movl $0x80084520, %esi       # imm = 0x80084520
movl %ebp, %edi
xorl %eax, %eax
callq 0x30f0
cmpl $0x0, (%r14)
jne 0x35f7
testb $0x2, 0x8(%rsp)
je 0x35f7
movl $0x0, (%r14)
addq $0x180001, %r15         # imm = 0x180001
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdx
movl %ebp, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x30f0
cmpl $0x0, (%r14)
jne 0x35f7
movdqa 0x10(%rsp), %xmm0
por 0x20(%rsp), %xmm0
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %eax
xorl %ebx, %ebx
xorl $0xf, %eax
setne %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/inspector.cc
// Function: print_mods(xkb_state*)
void print_mods(xkb_state * state) {
    struct {const char *name; const char *label;} mods[] = {
    {XKB_MOD_NAME_LOGO, "SUPER"},
    {XKB_MOD_NAME_ALT, "ALT"},
    {XKB_MOD_NAME_SHIFT, "SHIFT"},
    {XKB_MOD_NAME_CTRL, "CONTROL"},
    };
    int found = 0;
    for (auto & mod: mods) {
        if (xkb_state_mod_name_is_active(state, mod.name,
                                         XKB_STATE_MODS_EFFECTIVE) > 0) {
            if (found == 0) {
                printf("   XKB MODS: ");
            } else {
                printf(" ");
            }
            found++;
            printf("%s", mod.label);
        }
    }
    if (found > 0) {
        printf(";\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x355c(%rip), %r12      # 0x6d60
leaq 0x1387(%rip), %r14      # 0x4b92
leaq 0x1357(%rip), %r15      # 0x4b69
xorl %ebp, %ebp
xorl %r13d, %r13d
movq (%r13,%r12), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x30b0
testl %eax, %eax
jle 0x3858
testl %ebp, %ebp
je 0x383d
movl $0x20, %edi
callq 0x3040
jmp 0x3847
movq %r14, %rdi
xorl %eax, %eax
callq 0x30a0
incl %ebp
movq 0x8(%r13,%r12), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x30a0
addq $0x10, %r13
cmpq $0x40, %r13
jne 0x3817
testl %ebp, %ebp
jle 0x3880
leaq 0x169d(%rip), %rdi      # 0x4f0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3060
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/inspector.cc
// Function: read_events(xkb_keymap*, xkb_state*, Keyboard*)
void read_events(xkb_keymap *keymap,xkb_state *state, Keyboard *input) {
    struct input_event buf[16];
    errno = 0;
    int rd = read(input->fd, buf, sizeof(buf));
    struct input_event *end = buf + (rd / sizeof(struct input_event));
    int after_scancode = 0;
    for(const struct input_event *curr = buf; curr < end; curr++){
        if (curr->type != EV_KEY || curr->value == V_KEY_REPEAT) continue;
        xkb_keycode_t keycode;
        xkb_keysym_t keysym;
        keycode = curr->code + 8;
        keysym = xkb_state_key_get_one_sym(state, keycode);
        char keysym_name[64];
        xkb_keysym_get_name(keysym, keysym_name, sizeof(keysym_name));
        const char * keyname = xkb_keymap_key_get_name(keymap, keycode);
        printf("[%s]{\n",input->name);
        printf("   EVDEV: keycode:%d name:%s;\n", curr->code, key_code_name(curr->code));
        print_mods(state);
        printf("   XKB: key[%d]:<%s> keysym:%s;\n",
               keycode, keyname,keysym_name);
        if (curr->value == V_KEY_DOWN)
            xkb_state_update_key(state, keycode, XKB_KEY_DOWN);
        else if (curr->value == V_KEY_UP)
            xkb_state_update_key(state, keycode, XKB_KEY_UP);
        printf("}\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
callq 0x3050
movl $0x0, (%rax)
movq %rbx, (%rsp)
movl 0x4(%rbx), %edi
leaq 0x50(%rsp), %r12
movl $0x180, %edx            # imm = 0x180
movq %r12, %rsi
callq 0x3130
movslq %eax, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
cmpq $0x18, %rcx
jb 0x39df
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq (%rsp,%rax,8), %r13
addq $0x50, %r13
cmpw $0x1, 0x10(%r12)
jne 0x39d2
cmpl $0x2, 0x14(%r12)
je 0x39d2
movzwl 0x12(%r12), %ebp
addl $0x8, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x30d0
movl $0x40, %edx
movl %eax, %edi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x3070
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x31b0
movq %rax, %r15
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x1246(%rip), %rdi      # 0x4ba0
xorl %eax, %eax
callq 0x30a0
movzwl 0x12(%r12), %esi
cmpl $0xf8, %esi
leaq 0x382c(%rip), %rax      # 0x71a0
leaq (%rax,%rsi,8), %rax
leaq 0x3819(%rip), %rcx      # 0x7198
cmovaeq %rcx, %rax
movq (%rax), %rdx
leaq 0x121a(%rip), %rdi      # 0x4ba7
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
callq 0x37ef
leaq 0x1223(%rip), %rdi      # 0x4bc6
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30a0
movl 0x14(%r12), %edx
cmpl $0x1, %edx
ja 0x39c6
movq %r14, %rdi
movl %ebp, %esi
callq 0x3190
leaq 0x153f(%rip), %rdi      # 0x4f0c
callq 0x3060
addq $0x18, %r12
cmpq %r13, %r12
jb 0x38fc
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/inspector.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;
    while ((c = getopt (argc, argv, "hr:m:l:v:o:k")) != -1)
        switch(c){
            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 'k':
                setting.only_print = true;
                continue;
        }
    return setting;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x3448(%rip), %rax      # 0x6fe8
xorl %ecx, %ecx
movl %ecx, (%rax)
movq 0x3415(%rip), %rax      # 0x6fc0
movl %ecx, (%rax)
leaq 0x12fb(%rip), %r12      # 0x4eaf
leaq 0x449(%rip), %r13       # 0x4004
movq 0x3406(%rip), %rbx      # 0x6fc8
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31f0
leal -0x68(%rax), %ecx
cmpl $0xe, %ecx
ja 0x3c14
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x1, 0x28(%r14)
jmp 0x3bc2
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x3bc2
movq (%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x3bc2
movq (%rbx), %rax
movq %rax, 0x20(%r14)
jmp 0x3bc2
movq (%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x3bc2
movq (%rbx), %rax
movq %rax, 0x18(%r14)
jmp 0x3bc2
cmpl $-0x1, %eax
jne 0x3bc2
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movq (%rsp), %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3b76
xorl %edi, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/exrok[P]evdoublebind/./src/inspector.cc
// Function: main
int main(int argc, char *argv[]) {
    Settings settings = parse_arguments(Settings(), argc, argv);
    KeyboardList keyboards;
    find_keyboard_in(keyboards, "/dev/input/by-id/");
    find_keyboard_in(keyboards, "/dev/input/by-path/");
    if(settings.only_print) {
        keyboards.print();
        exit(1);
    }
    printf("Found %d Possible Keyboards.\n---\n", keyboards.len);
    keyboards.print();
    printf("---\n");
    if (poll_keyboard_events(settings, keyboards)) {
        perror("ERROR");
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rcx
movl %edi, %edx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b82
movl $0x0, 0x200(%rbx)
leaq 0x122a(%rip), %rsi      # 0x4ebc
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x3634
leaq 0x1228(%rip), %rsi      # 0x4ece
movq %rbx, %rdi
callq 0x3634
cmpb $0x1, 0x28(%r14)
je 0x3d24
movslq 0x230(%rsp), %rbx
leaq 0x121e(%rip), %rdi      # 0x4ee2
movl %ebx, %esi
xorl %eax, %eax
callq 0x30a0
testq %rbx, %rbx
jle 0x3cec
shlq $0x4, %rbx
xorl %r14d, %r14d
movq 0x38(%rsp,%r14), %rdi
callq 0x3060
addq $0x10, %r14
cmpq %r14, %rbx
jne 0x3cd9
leaq 0x121b(%rip), %rdi      # 0x4f0e
callq 0x3060
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x39f1
testl %eax, %eax
jne 0x3d16
xorl %eax, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
leaq 0x11e7(%rip), %rdi      # 0x4f04
callq 0x31e0
jmp 0x3d09
leaq 0x30(%rsp), %rdi
callq 0x3d38
movl $0x1, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/main.cpp
// Function: add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add(const string& name, const string& email) {
    if (name.empty() || email.empty()) {
        cout << EMPTY_NAME_EMAIL_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Profile profile(name, email);
    Store store;
    store.append(profile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
cmpq $0x0, 0x8(%rdi)
je 0x401c
movq %rsi, %rdx
cmpq $0x0, 0x8(%rsi)
je 0x401c
movq %rdi, %rsi
leaq -0x50(%rbp), %rdi
callq 0x530c
leaq -0x280(%rbp), %rdi
callq 0x548c
leaq -0x280(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x573c
leaq -0x280(%rbp), %rdi
callq 0x582c
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ffe
callq 0x21f0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4010
callq 0x21f0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
movq 0x5425(%rip), %rsi      # 0x9448
movq 0x5426(%rip), %rdx      # 0x9450
movq 0x4f97(%rip), %rbx      # 0x8fc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x531e(%rip), %rsi      # 0x9388
movq 0x531f(%rip), %rdx      # 0x9390
movq %rbx, %rdi
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
jmp 0x2230
movq %rax, %rbx
leaq -0x280(%rbp), %rdi
callq 0x582c
jmp 0x4098
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4a88
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/main.cpp
// Function: update(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void update(int number, const string& name, const string& email) {
    if (name.empty() || email.empty()) {
        cout << EMPTY_NAME_EMAIL_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Store store;
    if (number <= 0 || number > store.size()) {
        cout << NONEXISTENT_INDEX_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    Profile profile(name, email);
    store.update(number - 1, profile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
cmpq $0x0, 0x8(%rsi)
je 0x415e
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x415e
movq %rsi, %r15
movl %edi, %ebx
leaq -0x288(%rbp), %rdi
callq 0x548c
testl %ebx, %ebx
jle 0x40fb
leaq -0x288(%rbp), %rdi
callq 0x5814
cmpl %ebx, %eax
jge 0x41c8
movq 0x5326(%rip), %rsi      # 0x9428
movq 0x5327(%rip), %rdx      # 0x9430
movq 0x4eb8(%rip), %rdi      # 0x8fc8
callq 0x2230
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x5242(%rip), %rsi      # 0x9388
movq 0x5243(%rip), %rdx      # 0x9390
movq 0x4e74(%rip), %rdi      # 0x8fc8
callq 0x2230
jmp 0x420f
movq 0x52e3(%rip), %rsi      # 0x9448
movq 0x52e4(%rip), %rdx      # 0x9450
movq 0x4e55(%rip), %rbx      # 0x8fc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x51dc(%rip), %rsi      # 0x9388
movq 0x51dd(%rip), %rdx      # 0x9390
movq %rbx, %rdi
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2230
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x530c
decl %ebx
leaq -0x288(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movl %ebx, %esi
callq 0x5782
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41fd
callq 0x21f0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x420f
callq 0x21f0
leaq -0x288(%rbp), %rdi
callq 0x582c
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4a88
jmp 0x423c
jmp 0x4239
movq %rax, %rbx
leaq -0x288(%rbp), %rdi
callq 0x582c
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/main.cpp
// Function: remove(int)
void remove(int number) {
    Store store;
    if (number <= 0 || number > store.size()) {
        cout << NONEXISTENT_INDEX_MESSAGE << endl;
        cout << RUN_HELP_MESSAGE;
        return;
    }
    store.remove(number - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %edi, %ebx
leaq -0x238(%rbp), %rdi
callq 0x548c
testl %ebx, %ebx
jle 0x467a
leaq -0x238(%rbp), %rdi
callq 0x5814
cmpl %ebx, %eax
jge 0x46da
movq 0x4da7(%rip), %rsi      # 0x9428
movq 0x4da8(%rip), %rdx      # 0x9430
movq 0x4939(%rip), %rdi      # 0x8fc8
callq 0x2230
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x4cc3(%rip), %rsi      # 0x9388
movq 0x4cc4(%rip), %rdx      # 0x9390
movq 0x48f5(%rip), %rdi      # 0x8fc8
callq 0x2230
jmp 0x46ea
decl %ebx
leaq -0x238(%rbp), %rdi
movl %ebx, %esi
callq 0x57e2
leaq -0x238(%rbp), %rdi
callq 0x582c
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x582c
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/main.cpp
// Function: list()
void list() {
    Store store;
    int size = store.size();
    vector<Profile> profileList = store.getAll();
    for (int i = 0; i < size; i++) {
        cout << left;
        cout << setw(NUMBER_WIDTH) << i + 1;
        cout << setw(NAME_WIDTH) << profileList[i].getName();
        cout << setw(EMAIL_WIDTH) << profileList[i].getEmail();
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
leaq -0x270(%rbp), %rbx
movq %rbx, %rdi
callq 0x548c
movq %rbx, %rdi
callq 0x5814
movl %eax, %ebx
leaq -0x270(%rbp), %rdi
callq 0x5774
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x49c6
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x6, %rbx
movl $0x1, %r14d
movq 0x4852(%rip), %r15      # 0x8fc8
movl $0xffffff4f, %r13d      # imm = 0xFFFFFF4F
cmpq %r12, %rbx
je 0x483d
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r15,%rcx), %edx
andl %r13d, %edx
orl $0x20, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
movq $0x4, 0x10(%r15,%rax)
movq %r15, %rdi
movl %r14d, %esi
callq 0x2330
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x30, 0x10(%r15,%rax)
movq -0x40(%rbp), %rdi
addq %r12, %rdi
callq 0x53a0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2230
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x30, 0x10(%r15,%rax)
movq -0x40(%rbp), %rdi
addq %r12, %rdi
callq 0x53aa
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2230
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
addq $0x40, %r12
incl %r14d
movq %rax, %rdi
callq 0x2170
jmp 0x477c
leaq -0x40(%rbp), %rdi
callq 0x4a54
leaq -0x270(%rbp), %rdi
callq 0x582c
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4866
movq %rax, %rbx
jmp 0x4877
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4a54
leaq -0x270(%rbp), %rdi
callq 0x582c
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/Options/Options.cpp
// Function: Options::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string& Options::get(const string &option) {
    vector<string>::const_iterator itr;
    itr = find(this->tokens.begin(), this->tokens.end(), option);
    if (itr != this->tokens.end() && ++itr != this->tokens.end()){
        return *itr;
    }
    static const string empty_string("");
    return empty_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0x51cc
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpq %rax, %rbx
setne %cl
addq $0x20, %rbx
cmpq %rax, %rbx
setne %al
testb %al, %cl
jne 0x4ec1
movb 0x4652(%rip), %al       # 0x9508
leaq 0x462b(%rip), %rbx      # 0x94e8
testb %al, %al
je 0x4ec9
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4638(%rip), %rdi      # 0x9508
callq 0x2360
testl %eax, %eax
je 0x4ec1
leaq 0x4618(%rip), %rax      # 0x94f8
movq %rax, 0x4601(%rip)      # 0x94e8
leaq 0x45fa(%rip), %rbx      # 0x94e8
leaq 0x1405(%rip), %rdx      # 0x62fa
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4c12
movq 0x40a9(%rip), %rdi      # 0x8fb0
leaq 0x42d2(%rip), %rdx      # 0x91e0
movq %rbx, %rsi
callq 0x21d0
leaq 0x45eb(%rip), %rdi      # 0x9508
callq 0x2160
jmp 0x4ec1
movq %rax, %rbx
leaq 0x45da(%rip), %rdi      # 0x9508
callq 0x2150
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/XDragonSl[P]git-switcher/src/Store/Store.cpp
// Function: Store::~Store()
Store::~Store() {
    if (isChanged) {
        store.open(STORE_LOCATION + STORE_NAME, ios::out);
        for(Profile profile : allProfiles) {
            store << profile.toString() << endl;
        }
        store.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x228(%rdi)
jne 0x5986
leaq 0x3cbc(%rip), %rsi      # 0x9510
leaq 0x3cd5(%rip), %rdx      # 0x9530
leaq -0x70(%rbp), %rdi
movq %rbx, -0x30(%rbp)
callq 0x4abd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2280
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x588b
callq 0x21f0
movq 0x210(%rbx), %r13
movq 0x218(%rbx), %r14
cmpq %r14, %r13
je 0x597a
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %r15
leaq -0x70(%rbp), %r12
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4b74
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x4b74
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x53b4
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %r15, %rdi
callq 0x2230
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x5949
callq 0x21f0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x595b
callq 0x21f0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x596d
callq 0x21f0
addq $0x40, %r13
cmpq %r14, %r13
jne 0x58ae
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2050
leaq 0x210(%rbx), %rdi
callq 0x4a54
movq %rbx, %rdi
callq 0x2070
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x59ba
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x59ca
jmp 0x59ba
movq %rax, %rbx
jmp 0x59fc
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x59fc
callq 0x21f0
jmp 0x59fc
movq %rax, %rbx
jmp 0x59f3
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x59f3
callq 0x21f0
leaq -0x70(%rbp), %rdi
callq 0x4a88
movq -0x30(%rbp), %r14
leaq 0x210(%r14), %rdi
callq 0x4a54
movq %r14, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CPoint.cpp
// Function: CPoint::operator=(CPoint const&)
CPoint & CPoint::operator = ( CPoint const & src )
{
  if ( &src == this ) return *this;
  
  m_x = src.getX();
  m_y = src.getY();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rdi, %rsi
je 0x3854
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Update(int const&, int const&, int const&, char const&)
void CObstacle::Update ( int const & ox, int const & oy, int const & length, char const & mode )
{
  m_orig.setX ( ox );
  m_orig.setY ( oy );
  m_length = length;
  m_mode = mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
callq 0x3856
movq %r12, %rdi
movq %r15, %rsi
callq 0x3860
movl (%r14), %eax
movl %eax, 0x8(%r12)
movb (%rbx), %al
movb %al, 0xc(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Paint() const
void CObstacle::Paint ( void ) const
{
  int x = m_orig.getX();
  int y = m_orig.getY();
  
  switch ( m_mode )
  {
    case 'V':					// draw vertical object starting on the upper point
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
    case 'H':					// draw horizontal object starting on the left
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x, y+i );
	addch ( ' ' );
      }
      break;
    case 'D':					// draw diagonal object starting on the upper-left points
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y+i );
	addch ( ' ' );
      }
      break;
    case 'I':					// draw dashed vertical object starting from upper point
      for ( int i = 0; i < m_length; i+=2 )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
  }
  
  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x382c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3834
movl %eax, %r15d
movzbl 0xc(%rbx), %eax
cmpl $0x48, %eax
jg 0x39f5
cmpl $0x44, %eax
je 0x3a3d
cmpl $0x48, %eax
jne 0x3aa6
cmpl $0x0, 0x8(%rbx)
jle 0x3aa6
xorl %r12d, %r12d
movq 0x9603(%rip), %r13      # 0xcfd0
leal (%r15,%r12), %esi
movl %r14d, %edi
callq 0x31c0
movq (%r13), %rdi
movl $0x20, %esi
callq 0x30c0
incl %r12d
cmpl 0x8(%rbx), %r12d
jl 0x39cd
jmp 0x3aa6
cmpl $0x56, %eax
je 0x3a73
cmpl $0x49, %eax
jne 0x3aa6
cmpl $0x0, 0x8(%rbx)
jle 0x3aa6
xorl %r12d, %r12d
movq 0x95b9(%rip), %r13      # 0xcfd0
leal (%r14,%r12), %edi
movl %r15d, %esi
callq 0x31c0
movq (%r13), %rdi
movl $0x20, %esi
callq 0x30c0
addl $0x2, %r12d
cmpl 0x8(%rbx), %r12d
jl 0x3a17
jmp 0x3aa6
cmpl $0x0, 0x8(%rbx)
jle 0x3aa6
xorl %r12d, %r12d
movq 0x9583(%rip), %r13      # 0xcfd0
leal (%r14,%r12), %edi
leal (%r15,%r12), %esi
callq 0x31c0
movq (%r13), %rdi
movl $0x20, %esi
callq 0x30c0
incl %r12d
cmpl 0x8(%rbx), %r12d
jl 0x3a4d
jmp 0x3aa6
cmpl $0x0, 0x8(%rbx)
jle 0x3aa6
xorl %r12d, %r12d
movq 0x954d(%rip), %r13      # 0xcfd0
leal (%r14,%r12), %edi
movl %r15d, %esi
callq 0x31c0
movq (%r13), %rdi
movl $0x20, %esi
callq 0x30c0
incl %r12d
cmpl 0x8(%rbx), %r12d
jl 0x3a83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Intersection(CPoint const&) const
bool CObstacle::Intersection ( CPoint const & p ) const
{
  int px = p.getX();
  int py = p.getY();
  int ox = m_orig.getX();
  int oy = m_orig.getY();
  bool res;
  
  switch ( m_mode )
  {
    case 'V':
      res = ( (py == oy) && (px >= ox) && (px < (ox+m_length)) );
      break;
    case 'H':
      res = ( (px == ox) && (py >= oy) && (py < (oy+m_length)) );
      break;
    case 'D':
      res = ( (px >= ox) && (px < (ox+m_length)) && (py >= oy) && (py < (oy+m_length)) && ((py-px) == (oy-ox)) );
      break;
    case 'I':
      res = ( (py == oy) && (px >= ox) && (px < (ox+m_length)) && ((px%2) == (ox%2)) );
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x382c
movl %eax, %ebx
movq %r14, %rdi
callq 0x3834
movl %eax, %r12d
movq %r15, %rdi
callq 0x382c
movl %eax, %r14d
movq %r15, %rdi
callq 0x3834
movzbl 0xc(%r15), %ecx
cmpl $0x48, %ecx
jg 0x3b9c
cmpl $0x44, %ecx
jne 0x3bdf
cmpl %r14d, %ebx
jl 0x3c08
movl 0x8(%r15), %ecx
leal (%rcx,%r14), %edx
cmpl %edx, %ebx
setl %dl
cmpl %eax, %r12d
setge %sil
addl %eax, %ecx
cmpl %ecx, %r12d
setl %cl
andb %dl, %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x3c08
subl %ebx, %r12d
subl %r14d, %eax
cmpl %eax, %r12d
jmp 0x3bda
cmpl $0x49, %ecx
jne 0x3bf8
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
jne 0x3c08
movl 0x8(%r15), %eax
addl %r14d, %eax
cmpl %eax, %ebx
jge 0x3c08
movl %ebx, %eax
shrl $0x1f, %eax
addl %ebx, %eax
andl $-0x2, %eax
subl %eax, %ebx
movl %r14d, %eax
shrl $0x1f, %eax
addl %r14d, %eax
andl $-0x2, %eax
subl %eax, %r14d
cmpl %r14d, %ebx
sete %al
jmp 0x3c18
cmpl %r14d, %ebx
setne %cl
cmpl %eax, %r12d
setl %dl
orb %cl, %dl
jne 0x3c08
addl 0x8(%r15), %eax
cmpl %eax, %r12d
jmp 0x3c15
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
je 0x3c0c
xorl %eax, %eax
jmp 0x3c18
movl 0x8(%r15), %eax
addl %r14d, %eax
cmpl %eax, %ebx
setl %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::CSnake()
CSnake::CSnake ( void )
{
  m_size = 0;
  m_max_size = 150;
  m_body = new CPoint [150];
  m_head = 0;
  m_tail = 0;
  m_score = 0;
  m_delay = 0;
  m_lives = 5;
  m_direction = '-';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x8ed4(%rip), %rax      # 0xcb10
movq %rax, (%rdi)
movq %rdi, -0x38(%rbp)
movq $0x96, 0x10(%rdi)
movl $0x4b0, %edi            # imm = 0x4B0
callq 0x3030
movq %rax, %r14
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
leaq -0x2c(%rbp), %r12
xorl %ebx, %ebx
leaq (%r14,%rbx), %rdi
movl %r13d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq %r15, %rsi
movq %r12, %rdx
callq 0x380c
addq $0x8, %rbx
cmpq $0x4b0, %rbx            # imm = 0x4B0
jne 0x3c65
movq -0x38(%rbp), %rax
movq %r14, 0x8(%rax)
movaps 0x5398(%rip), %xmm0     # 0x9030
movups %xmm0, 0x18(%rax)
movl $0x0, 0x2c(%rax)
movb $0x2d, 0x28(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x4b0, %esi            # imm = 0x4B0
movq %r14, %rdi
callq 0x3420
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::hasPoint(CPoint const&) const
bool CSnake::hasPoint ( CPoint const & p ) const
{ 
  if ( !m_lives ) return false;
  
  int i = m_head;
  for ( int k = 0; k < m_size; k++ )
  {
    if ( m_body[i] == p ) return true;
    i = (i + (m_max_size - 1)) % m_max_size;
  }
  return false;
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
je 0x3d60
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x14(%rdi)
jle 0x3d64
movq %rsi, %rbx
movl 0x18(%r14), %r15d
movslq %r15d, %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x38a8
movl %eax, %ecx
testb %al, %al
jne 0x3d66
movl 0x10(%r14), %esi
leal (%r15,%rsi), %eax
decl %eax
cltd
idivl %esi
incl %r12d
movl %edx, %r15d
cmpl 0x14(%r14), %r12d
jl 0x3d2c
jmp 0x3d66
xorl %ecx, %ecx
jmp 0x3d6e
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::Eat(CPoint const&, int const&, int const&)
bool CSnake::Eat ( CPoint const & food, int const & nfood, int const & level )
{
  if ( !m_lives ) return false;
  
  if ( m_body[m_head] == food )
  {
    m_delay += (3 * nfood);
    m_score += ( 100*level + 100*nfood );
    return true;
  }
  return false;
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
je 0x3dba
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movslq 0x18(%rdi), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
callq 0x38a8
testb %al, %al
je 0x3dbd
movl (%r15), %eax
leal (%rax,%rax,2), %eax
addl %eax, 0x2c(%r14)
movl (%r15), %eax
addl (%rbx), %eax
imull $0x64, %eax, %eax
addl %eax, 0x20(%r14)
movb $0x1, %al
jmp 0x3dbf
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSingle.cpp
// Function: CSingle::Collision(CObstacle*, int const&, CSnake*)
bool CSingle::Collision ( CObstacle * const obstacles, int const & num_obstacles, CSnake * sfriend )
{
  if ( !m_lives ) return false;
  
  // collision with obstacles
  for ( int i = 0; i < num_obstacles; i++ )
    if ( obstacles[i].Intersection ( m_body[m_head] ) )
    {
      m_lives --;
      m_score -= 1000;
      return true;
    }
  
  // collision with body
  int i = m_tail;
  for ( int k = 0; k < m_size-3; k++ )
  {
    if ( m_body[m_head] == m_body[i] )
    {
      m_lives --;
      m_score -= 1000;
      return true;
    }
    i = (i + 1) % m_max_size;
  }
  
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x24(%rdi)
je 0x4081
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdx)
jle 0x403d
movq %rsi, %r15
xorl %r12d, %r12d
movslq 0x18(%rbx), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x3b1a
testb %al, %al
jne 0x4086
incq %r12
movslq (%r14), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4016
xorl %r14d, %r14d
cmpl $0x4, 0x14(%rbx)
jl 0x4093
movl 0x1c(%rbx), %r15d
movq 0x8(%rbx), %rax
movslq 0x18(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
movslq %r15d, %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x38a8
testb %al, %al
jne 0x4086
incl %r15d
movl %r15d, %eax
cltd
idivl 0x10(%rbx)
incl %r14d
movl 0x14(%rbx), %eax
addl $-0x3, %eax
movl %edx, %r15d
cmpl %eax, %r14d
jl 0x404a
xorl %r14d, %r14d
jmp 0x4093
decl 0x24(%rbx)
addl $0xfffffc18, 0x20(%rbx) # imm = 0xFFFFFC18
movb $0x1, %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CMultPC.cpp
// Function: CMultPC::Collision(CObstacle*, int const&, CSnake*)
bool CMultPC::Collision ( CObstacle * const obstacles, int const & num_obstacles, CSnake * sfriend )
{
  if ( !m_lives ) return false;
  
  // collision with obstacles
  for ( int i = 0; i < num_obstacles; i++ )
    if ( obstacles[i].Intersection ( m_body[m_head] ) )
    {
      Die ( dynamic_cast <CMultPC*> (sfriend) );
      m_score -= 1000;
      return true;
    }
  
  // collision with itself
  int i = m_tail;
  for ( int k = 0; k < m_size-3; k++ )
  {
    if ( m_body[m_head] == m_body[i] )
    {
      Die ( dynamic_cast <CMultPC*> (sfriend) );
      m_score -= 1000;
      return true;
    }
    i = (i + 1) % m_max_size;
  }
  
  // collision with friend
  if ( sfriend ) 
    if ( sfriend->hasPoint ( m_body[m_head] ) )
    {
      Die ( dynamic_cast <CMultPC*> (sfriend) );
      m_score -= 1000;
      return true;
    }
  
  return false;
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
je 0x4560
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x0, (%rdx)
jle 0x44d3
movq %rsi, %r12
xorl %r13d, %r13d
movslq 0x18(%rbx), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x3b1a
testb %al, %al
jne 0x4563
incq %r13
movslq (%r15), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x44a8
cmpl $0x4, 0x14(%rbx)
jl 0x4517
movl 0x1c(%rbx), %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movslq 0x18(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
movslq %r15d, %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x38a8
testb %al, %al
jne 0x4563
incl %r15d
movl %r15d, %eax
cltd
idivl 0x10(%rbx)
incl %r12d
movl 0x14(%rbx), %eax
addl $-0x3, %eax
movl %edx, %r15d
cmpl %eax, %r12d
jl 0x44e0
testq %r14, %r14
je 0x4582
movslq 0x18(%rbx), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3d08
testb %al, %al
je 0x4582
movl 0x24(%rbx), %r15d
testl %r15d, %r15d
jle 0x459a
leaq 0x8604(%rip), %rsi      # 0xcb48
leaq 0x86b5(%rip), %rdx      # 0xcc00
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x32c0
decl %r15d
movl %r15d, 0x24(%rbx)
jne 0x459a
jmp 0x4596
xorl %eax, %eax
retq
testq %r14, %r14
je 0x4586
leaq 0x85d9(%rip), %rsi      # 0xcb48
leaq 0x868a(%rip), %rdx      # 0xcc00
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x32c0
jmp 0x4588
xorl %eax, %eax
jmp 0x45a3
xorl %eax, %eax
movl 0x24(%rbx), %ecx
testl %ecx, %ecx
jle 0x459a
decl %ecx
movl %ecx, 0x24(%rbx)
jne 0x459a
movb $0x0, 0x3c(%rax)
addl $0xfffffc18, 0x20(%rbx) # imm = 0xFFFFFC18
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CMultPC.cpp
// Function: CMultPC::Die(CMultPC*)
void CMultPC::Die ( CMultPC * sfriend )
{
  if ( m_lives > 0 )
  {
    m_lives --;
    if ( !m_lives )
      sfriend->ManDown();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x45c8
decl %eax
movl %eax, 0x24(%rdi)
jne 0x45c8
movb $0x0, 0x3c(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CMultNet.cpp
// Function: CMultNet::Move()
bool CMultNet::Move ( void )
{
  if ( !m_lives ) return true;
  
  char buffer[10];
  bzero ( buffer, 10 );
  
  if ( m_isHost )	// the snake controlled by this computer
  {
    CSingle::Move();
    sprintf ( buffer, "M%c", m_direction );
    if ( ! m_socket->Send ( buffer, 3 ) ) return false;
    bzero ( buffer, 3 );
    if ( ! m_socket->Recv ( buffer, 3 ) ) return false;
    if ( buffer[0] != 'O' || buffer[1] != 'K' ) return false;
  }
  else			// the snake controlled by remote computer
  {
    if ( ! m_socket->Recv ( buffer, 3 ) ) return false;
    if ( buffer[0] != 'M' ) return false;
    m_direction = buffer[1];
    
    switch ( m_direction )
    {
      case 'U':
	ungetch ( KEY_UP );
	break;
      case 'D':
	ungetch ( KEY_DOWN );
	break;
      case 'L':
	ungetch ( KEY_LEFT );
	break;
      case 'R':
	ungetch ( KEY_RIGHT );
	break;
      default:
	return false;
	break;
    }
    CSingle::Move();
    sprintf ( buffer, "OK" );
    if ( ! m_socket->Send ( buffer, 3 ) ) return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x24(%rdi)
je 0x49d6
movq %rdi, %rbx
movw $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpb $0x1, 0x3d(%rdi)
jne 0x4942
movq %rbx, %rdi
callq 0x40a0
movsbl 0x28(%rbx), %edx
leaq 0x4800(%rip), %rsi      # 0x90cd
xorl %r14d, %r14d
leaq -0x28(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3070
movq 0x40(%rbx), %rdi
leaq -0x2c(%rbp), %rdx
movl $0x3, (%rdx)
movq (%rdi), %rax
movq %r15, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x49de
leaq -0x28(%rbp), %rsi
movb $0x0, 0x2(%rsi)
movw $0x0, (%rsi)
movq 0x40(%rbx), %rdi
leaq -0x2c(%rbp), %rdx
movl $0x3, (%rdx)
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x49db
xorl %r14d, %r14d
cmpb $0x4f, -0x28(%rbp)
jne 0x49de
cmpb $0x4b, -0x27(%rbp)
je 0x49d6
jmp 0x49de
movq 0x40(%rbx), %rdi
leaq -0x2c(%rbp), %rdx
movl $0x3, (%rdx)
movq (%rdi), %rax
leaq -0x28(%rbp), %rsi
callq *0x28(%rax)
xorl %r14d, %r14d
testb %al, %al
je 0x49de
cmpb $0x4d, -0x28(%rbp)
jne 0x49de
movzbl -0x27(%rbp), %eax
movb %al, 0x28(%rbx)
xorl %r14d, %r14d
cmpl $0x51, %eax
jg 0x4987
cmpl $0x44, %eax
je 0x4998
cmpl $0x4c, %eax
jne 0x49de
movl $0x104, %edi            # imm = 0x104
jmp 0x49a4
cmpl $0x52, %eax
je 0x499f
movl $0x103, %edi            # imm = 0x103
cmpl $0x55, %eax
je 0x49a4
jmp 0x49de
movl $0x102, %edi            # imm = 0x102
jmp 0x49a4
movl $0x105, %edi            # imm = 0x105
callq 0x3350
movq %rbx, %rdi
callq 0x40a0
leaq -0x28(%rbp), %rsi
movw $0x4b4f, (%rsi)         # imm = 0x4B4F
movb $0x0, 0x2(%rsi)
movq 0x40(%rbx), %rdi
leaq -0x2c(%rbp), %rdx
movl $0x3, (%rdx)
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x49db
movb $0x1, %r14b
jmp 0x49de
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSocketServer.cpp
// Function: CSocketServer::Initialize(int const&, char*)
bool CSocketServer::Initialize ( int const & portno, char * hostname )
{
  m_sockfd = socket ( AF_INET, SOCK_STREAM, 0 );
  if ( m_sockfd < 0 ) return false;
  
  bzero ( (char*) (&m_serverAddr), sizeof(m_serverAddr) );
  m_portno = portno;
  m_serverAddr.sin_family = AF_INET;
  m_serverAddr.sin_addr.s_addr = INADDR_ANY;
  m_serverAddr.sin_port = htons ( m_portno );
  
  int s;
  s = bind ( m_sockfd, (struct sockaddr*) (&m_serverAddr), sizeof( m_serverAddr ) );
  if ( s < 0 ) return false;
  listen ( m_sockfd, 5 );
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movl %eax, 0x24(%rbx)
testl %eax, %eax
js 0x4b8e
leaq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl (%r15), %ecx
movl %ecx, 0xc(%rbx)
movw $0x2, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
rolw $0x8, %cx
movw %cx, 0x12(%rbx)
movl %eax, %edi
movl $0x10, %edx
callq 0x3050
testl %eax, %eax
js 0x4b8b
movl 0x24(%rbx), %edi
movl $0x5, %esi
callq 0x32b0
movb $0x1, %r14b
jmp 0x4b8e
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSocketServer.cpp
// Function: CSocketServer::EstablishConnection()
bool CSocketServer::EstablishConnection ( void )
{
  m_clientLength = sizeof ( m_clientAddr );
  m_newsockfd = accept ( m_sockfd, (struct sockaddr*) (&m_clientAddr), &m_clientLength );
  if ( m_newsockfd < 0 ) return false;
  
  m_connected = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %rdx
movl $0x10, 0x38(%rdi)
movl 0x24(%rdi), %edi
leaq 0x28(%rbx), %rsi
callq 0x30d0
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0x4bc7
movb $0x1, 0x20(%rbx)
testl %eax, %eax
setns %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CSocketClient.cpp
// Function: CSocketClient::Initialize(int const&, char*)
bool CSocketClient::Initialize ( int const & portno, char * hostname )
{
  m_portno = portno;
  m_newsockfd = socket ( AF_INET, SOCK_STREAM, 0 );
  if ( m_newsockfd < 0 ) return false;
  m_server = gethostbyname ( hostname );
  if ( m_server == NULL ) return false;
  
  bzero ( (char*) (&m_serverAddr), sizeof( m_serverAddr ) );
  m_serverAddr.sin_family = AF_INET;
  bcopy ( (char*) m_server->h_addr, (char*) (&m_serverAddr.sin_addr.s_addr), m_server->h_length );
  m_serverAddr.sin_port = htons ( m_portno );
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, 0xc(%rdi)
xorl %r14d, %r14d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0x4c9e
movq %r15, %rdi
callq 0x32d0
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x4c9b
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movw $0x2, 0x10(%rbx)
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x14(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x33b0
movzwl 0xc(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x12(%rbx)
movb $0x1, %r14b
jmp 0x4c9e
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::~CNibbles()
CNibbles::~CNibbles ( void )
{
  for ( int i = 0; i < 2; i++ )
    if ( m_snakes[i] ) delete m_snakes[i];
  delete [] m_snakes;
  delete [] m_obstacles;
  if ( m_mode == 3 && m_socket ) delete m_socket;
  nodelay( stdscr, false );
  endwin ();
  
  if ( m_state == 5 )
  {
    cout << "\nThe program has aborted!\nReason:" << endl;
    cout << " - " << m_exception << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %r14b
xorl %eax, %eax
movq 0x30(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x4f6e
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, %eax
testb $0x1, %r14b
movl $0x0, %r14d
jne 0x4f5b
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x4f8d
callq 0x3340
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4f9b
callq 0x3340
cmpl $0x3, 0x14(%rbx)
jne 0x4fb0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x4fb0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8019(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3190
callq 0x3300
cmpl $0x5, 0x24(%rbx)
jne 0x5068
movq 0x8001(%rip), %r14      # 0xcfd8
leaq 0x4241(%rip), %rsi      # 0x921f
movl $0x21, %edx
movq %r14, %rdi
callq 0x32e0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq 0x7fcf(%rip), %rdi      # 0xcfd8
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x7fbb(%rip), %rdi      # 0xcfd8
leaq 0x421d(%rip), %rsi      # 0x9241
movl $0x3, %edx
callq 0x32e0
leaq 0x50(%rbx), %rsi
movq 0x7f9f(%rip), %rdi      # 0xcfd8
callq 0x3684
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x50(%rbx), %rdi
addq $0x60, %rbx
cmpq %rbx, %rdi
je 0x5084
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3280
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x4a94
nop
// File: /workspace/github_cpp_makefile_star2_O3/matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::Start()
void CNibbles::Start ( void )
{
  try
  {
    Menu ();
    
    m_state = 2; // next level;
    for ( m_level = 1; m_level <= 10; m_level++ )
    {
      InitLevel ( );
      m_state = 0; // normal game curse
      while ( Step() )	usleep ( m_speed );
      // - same level (player dies)   	-> 1
      // - next level			-> 2
      // - game over			-> 3
      // - winner				
      // - Abort Execution		-> 5
      if ( m_state == 1 )		m_level--;
      else if ( m_state == 3 )
      {
	if ( GameOver_Restart() ) 	Restart ();
	else				break;
      }
      if ( m_level == 10 )
      {
	if ( Winner_Restart() )	Restart ();
	else 			break;
      }
	
    }
  }
  catch (CException e)
  {
    m_exception = e;
    m_state = 5;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x521c
movl $0x2, 0x24(%rbx)
movl $0x1, 0x8(%rbx)
movabsq $0x200000000, %r14      # imm = 0x200000000
movq %rbx, %rdi
callq 0x5d82
movl $0x0, 0x24(%rbx)
movq %rbx, %rdi
callq 0x66b4
testb %al, %al
je 0x50e4
movl 0x1c(%rbx), %edi
callq 0x3360
jmp 0x50ce
movl 0x24(%rbx), %eax
cmpl $0x3, %eax
je 0x50fb
cmpl $0x1, %eax
jne 0x512c
movl 0x8(%rbx), %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x512f
movq %rbx, %rdi
callq 0x69d0
testb %al, %al
je 0x517f
cmpl $0x0, 0x10(%rbx)
jle 0x5163
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x5110
jmp 0x5163
movl 0x8(%rbx), %eax
cmpl $0xa, %eax
jne 0x5170
movq %rbx, %rdi
callq 0x6f26
testb %al, %al
je 0x517f
cmpl $0x0, 0x10(%rbx)
jle 0x5163
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x5149
movq %r14, 0x20(%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
cmpl $0xa, %eax
jl 0x50bf
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5192
jmp 0x5192
jmp 0x5192
jmp 0x5192
movq %rax, %r14
cmpl $0x1, %edx
jne 0x520b
movq %r14, %rdi
callq 0x3320
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3616
movq %r14, %rdi
callq 0x3130
leaq 0x50(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3664
movl $0x5, 0x24(%rbx)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51e3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3280
callq 0x33c0
jmp 0x517f
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5206
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3280
callq 0x33c0
movq %r14, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x4a94
nop