LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x350d
cmpl $0x4, %eax
je 0x352e
cmpl $0x1, %eax
jne 0x359e
movq 0x3ae8(%rip), %rax      # 0x6fb8
movzwl 0x12(%rdi), %ecx
cmpl $0xf8, %ecx
leaq 0x3cbf(%rip), %rdx      # 0x71a0
leaq (%rdx,%rcx,8), %rdx
leaq 0x3cac(%rip), %rsi      # 0x7198
cmovbq %rdx, %rsi
movq (%rax), %rax
movq (%rsi), %rdx
movl 0x14(%rdi), %r9d
cmpq $0x2, %r9
ja 0x354f
leaq 0x3899(%rip), %rsi      # 0x6da0
movq (%rsi,%r9,8), %r8
jmp 0x3556
movq 0x3aa4(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x3, %rcx
ja 0x3567
leaq 0x3c48(%rip), %rdx      # 0x7170
movq (%rdx,%rcx,8), %rdx
jmp 0x356e
movq 0x3a83(%rip), %rax      # 0x6fb8
movq (%rax), %rax
movzwl 0x12(%rdi), %ecx
cmpq $0x6, %rcx
ja 0x3582
leaq 0x4417(%rip), %rdx      # 0x7960
movq (%rdx,%rcx,8), %rdx
jmp 0x3589
leaq 0x15b7(%rip), %r8       # 0x4b0d
leaq 0x15cf(%rip), %rsi      # 0x4b2c
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x15b2(%rip), %rdx      # 0x4b20
movl 0x14(%rdi), %ecx
leaq 0x15dd(%rip), %rsi      # 0x4b55
movq %rax, %rdi
xorl %eax, %eax
jmp 0x3160
leaq 0x158b(%rip), %rdx      # 0x4b14
movl 0x14(%rdi), %r8d
leaq 0x15ae(%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_O1/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 0x3647
testb $0x2, 0x8(%rsp)
je 0x3647
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 0x3647
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_O1/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 0x3501(%rip), %r12      # 0x6d60
leaq 0x132c(%rip), %r14      # 0x4b92
leaq 0x12fc(%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 0x38b3
testl %ebp, %ebp
je 0x3898
movl $0x20, %edi
callq 0x3040
jmp 0x38a2
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 0x3872
testl %ebp, %ebp
jle 0x38db
leaq 0x1642(%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_O1/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 0x3a3a
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq (%rsp,%rax,8), %r13
addq $0x50, %r13
cmpw $0x1, 0x10(%r12)
jne 0x3a2d
cmpl $0x2, 0x14(%r12)
je 0x3a2d
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 0x11eb(%rip), %rdi      # 0x4ba0
xorl %eax, %eax
callq 0x30a0
movzwl 0x12(%r12), %esi
cmpl $0xf8, %esi
leaq 0x37d1(%rip), %rax      # 0x71a0
leaq (%rax,%rsi,8), %rax
leaq 0x37be(%rip), %rcx      # 0x7198
cmovaeq %rcx, %rax
movq (%rax), %rdx
leaq 0x11bf(%rip), %rdi      # 0x4ba7
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
callq 0x384a
leaq 0x11c8(%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 0x3a21
movq %r14, %rdi
movl %ebp, %esi
callq 0x3190
leaq 0x14e4(%rip), %rdi      # 0x4f0c
callq 0x3060
addq $0x18, %r12
cmpq %r13, %r12
jb 0x3957
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33c1(%rip), %rax      # 0x6fe8
xorl %ecx, %ecx
movl %ecx, (%rax)
movq 0x338e(%rip), %rax      # 0x6fc0
movl %ecx, (%rax)
leaq 0x1274(%rip), %r12      # 0x4eaf
leaq 0x3c2(%rip), %r13       # 0x4004
movq 0x337f(%rip), %rbx      # 0x6fc8
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31f0
leal -0x68(%rax), %ecx
cmpl $0xe, %ecx
ja 0x3c9b
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x1, 0x28(%r14)
jmp 0x3c49
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x3c49
movq (%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x3c49
movq (%rbx), %rax
movq %rax, 0x20(%r14)
jmp 0x3c49
movq (%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x3c49
movq (%rbx), %rax
movq %rax, 0x18(%r14)
jmp 0x3c49
cmpl $-0x1, %eax
jne 0x3c49
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 0x3bfd
xorl %edi, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c09
movl $0x0, 0x200(%rbx)
leaq 0x11a3(%rip), %rsi      # 0x4ebc
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x3684
leaq 0x11a1(%rip), %rsi      # 0x4ece
movq %rbx, %rdi
callq 0x3684
cmpb $0x1, 0x28(%r14)
je 0x3db7
movl 0x230(%rsp), %esi
leaq 0x1198(%rip), %rdi      # 0x4ee2
xorl %eax, %eax
callq 0x30a0
cmpl $0x0, 0x230(%rsp)
jle 0x3d7f
leaq 0x38(%rsp), %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x3060
incq %r14
movslq 0x230(%rsp), %rax
addq $0x10, %rbx
cmpq %rax, %r14
jl 0x3d63
leaq 0x1188(%rip), %rdi      # 0x4f0e
callq 0x3060
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3a4c
testl %eax, %eax
jne 0x3da9
xorl %eax, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
leaq 0x1154(%rip), %rdi      # 0x4f04
callq 0x31e0
jmp 0x3d9c
leaq 0x30(%rsp), %rdi
callq 0x3dcc
movl $0x1, %edi
callq 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4199
movq %rsi, %rdx
cmpq $0x0, 0x8(%rsi)
je 0x4199
movq %rdi, %rsi
leaq -0x50(%rbp), %rdi
callq 0x5468
leaq -0x280(%rbp), %rdi
callq 0x55e8
leaq -0x280(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5898
leaq -0x280(%rbp), %rdi
callq 0x5988
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x417b
callq 0x21f0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x418d
callq 0x21f0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
movq 0x52a8(%rip), %rsi      # 0x9448
movq 0x52a9(%rip), %rdx      # 0x9450
movq 0x4e1a(%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 0x51a1(%rip), %rsi      # 0x9388
movq 0x51a2(%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 0x5988
jmp 0x4215
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4c04
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42db
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x42db
movq %rsi, %r15
movl %edi, %ebx
leaq -0x288(%rbp), %rdi
callq 0x55e8
testl %ebx, %ebx
jle 0x4278
leaq -0x288(%rbp), %rdi
callq 0x5970
cmpl %ebx, %eax
jge 0x4345
movq 0x51a9(%rip), %rsi      # 0x9428
movq 0x51aa(%rip), %rdx      # 0x9430
movq 0x4d3b(%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 0x50c5(%rip), %rsi      # 0x9388
movq 0x50c6(%rip), %rdx      # 0x9390
movq 0x4cf7(%rip), %rdi      # 0x8fc8
callq 0x2230
jmp 0x438c
movq 0x5166(%rip), %rsi      # 0x9448
movq 0x5167(%rip), %rdx      # 0x9450
movq 0x4cd8(%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 0x505f(%rip), %rsi      # 0x9388
movq 0x5060(%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 0x5468
decl %ebx
leaq -0x288(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movl %ebx, %esi
callq 0x58de
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x437a
callq 0x21f0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x438c
callq 0x21f0
leaq -0x288(%rbp), %rdi
callq 0x5988
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4c04
jmp 0x43b9
jmp 0x43b6
movq %rax, %rbx
leaq -0x288(%rbp), %rdi
callq 0x5988
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55e8
testl %ebx, %ebx
jle 0x47f7
leaq -0x238(%rbp), %rdi
callq 0x5970
cmpl %ebx, %eax
jge 0x4857
movq 0x4c2a(%rip), %rsi      # 0x9428
movq 0x4c2b(%rip), %rdx      # 0x9430
movq 0x47bc(%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 0x4b46(%rip), %rsi      # 0x9388
movq 0x4b47(%rip), %rdx      # 0x9390
movq 0x4778(%rip), %rdi      # 0x8fc8
callq 0x2230
jmp 0x4867
decl %ebx
leaq -0x238(%rbp), %rdi
movl %ebx, %esi
callq 0x593e
leaq -0x238(%rbp), %rdi
callq 0x5988
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x5988
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55e8
movq %rbx, %rdi
callq 0x5970
movl %eax, %ebx
leaq -0x270(%rbp), %rdi
callq 0x58d0
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4b42
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
shlq $0x6, %rbx
movl $0x1, %r14d
movq 0x46d5(%rip), %r15      # 0x8fc8
movl $0xffffff4f, %r13d      # imm = 0xFFFFFF4F
cmpq %r12, %rbx
je 0x49ba
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 0x54fc
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 0x5506
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 0x48f9
leaq -0x40(%rbp), %rdi
callq 0x4bd0
leaq -0x270(%rbp), %rdi
callq 0x5988
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49e3
movq %rax, %rbx
jmp 0x49f4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4bd0
leaq -0x270(%rbp), %rdi
callq 0x5988
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5338
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpq %rax, %rbx
setne %cl
addq $0x20, %rbx
cmpq %rax, %rbx
setne %al
testb %al, %cl
jne 0x502d
movb 0x44e6(%rip), %al       # 0x9508
leaq 0x44bf(%rip), %rbx      # 0x94e8
testb %al, %al
je 0x5035
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x44cc(%rip), %rdi      # 0x9508
callq 0x2360
testl %eax, %eax
je 0x502d
leaq 0x44ac(%rip), %rax      # 0x94f8
movq %rax, 0x4495(%rip)      # 0x94e8
leaq 0x448e(%rip), %rbx      # 0x94e8
leaq 0x1299(%rip), %rdx      # 0x62fa
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4d80
movq 0x3f3d(%rip), %rdi      # 0x8fb0
leaq 0x4166(%rip), %rdx      # 0x91e0
movq %rbx, %rsi
callq 0x21d0
leaq 0x447f(%rip), %rdi      # 0x9508
callq 0x2160
jmp 0x502d
movq %rax, %rbx
leaq 0x446e(%rip), %rdi      # 0x9508
callq 0x2150
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ae2
leaq 0x3b60(%rip), %rsi      # 0x9510
leaq 0x3b79(%rip), %rdx      # 0x9530
leaq -0x70(%rbp), %rdi
movq %rbx, -0x30(%rbp)
callq 0x4c39
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2280
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59e7
callq 0x21f0
movq 0x210(%rbx), %r13
movq 0x218(%rbx), %r14
cmpq %r14, %r13
je 0x5ad6
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 0x4ce6
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x4ce6
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x5510
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 0x5aa5
callq 0x21f0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5ab7
callq 0x21f0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5ac9
callq 0x21f0
addq $0x40, %r13
cmpq %r14, %r13
jne 0x5a0a
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2050
leaq 0x210(%rbx), %rdi
callq 0x4bd0
movq %rbx, %rdi
callq 0x2070
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b16
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x5b26
jmp 0x5b16
movq %rax, %rbx
jmp 0x5b58
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5b58
callq 0x21f0
jmp 0x5b58
movq %rax, %rbx
jmp 0x5b4f
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x5b4f
callq 0x21f0
leaq -0x70(%rbp), %rdi
callq 0x4c04
movq -0x30(%rbp), %r14
leaq 0x210(%r14), %rdi
callq 0x4bd0
movq %r14, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x384c
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::CObstacle(int const&, int const&, int const&, char const&)
CObstacle::CObstacle ( int const & ox, int const & oy, int const & length, char const & mode )
		      : m_orig ( ox, oy )
{
  m_length = length;
  m_mode = mode;
  m_cp_draw = 2;
  m_cp_erase = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
callq 0x3804
movl (%r14), %eax
movl %eax, 0x8(%r15)
movb (%rbx), %al
movb %al, 0xc(%r15)
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x384e
movq %r12, %rdi
movq %r15, %rsi
callq 0x3858
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_O1/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 0x3824
movl %eax, %r14d
movq %rbx, %rdi
callq 0x382c
movl %eax, %r15d
movzbl 0xc(%rbx), %eax
cmpl $0x48, %eax
jg 0x39ed
cmpl $0x44, %eax
je 0x3a35
cmpl $0x48, %eax
jne 0x3a9e
cmpl $0x0, 0x8(%rbx)
jle 0x3a9e
xorl %r12d, %r12d
movq 0x960b(%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 0x39c5
jmp 0x3a9e
cmpl $0x56, %eax
je 0x3a6b
cmpl $0x49, %eax
jne 0x3a9e
cmpl $0x0, 0x8(%rbx)
jle 0x3a9e
xorl %r12d, %r12d
movq 0x95c1(%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 0x3a0f
jmp 0x3a9e
cmpl $0x0, 0x8(%rbx)
jle 0x3a9e
xorl %r12d, %r12d
movq 0x958b(%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 0x3a45
jmp 0x3a9e
cmpl $0x0, 0x8(%rbx)
jle 0x3a9e
xorl %r12d, %r12d
movq 0x9555(%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 0x3a7b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3824
movl %eax, %ebx
movq %r14, %rdi
callq 0x382c
movl %eax, %r12d
movq %r15, %rdi
callq 0x3824
movl %eax, %r14d
movq %r15, %rdi
callq 0x382c
movzbl 0xc(%r15), %ecx
cmpl $0x48, %ecx
jg 0x3b94
cmpl $0x44, %ecx
jne 0x3bd7
cmpl %r14d, %ebx
jl 0x3c00
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 0x3c00
subl %ebx, %r12d
subl %r14d, %eax
cmpl %eax, %r12d
jmp 0x3bd2
cmpl $0x49, %ecx
jne 0x3bf0
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
jne 0x3c00
movl 0x8(%r15), %eax
addl %r14d, %eax
cmpl %eax, %ebx
jge 0x3c00
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 0x3c10
cmpl %r14d, %ebx
setne %cl
cmpl %eax, %r12d
setl %dl
orb %cl, %dl
jne 0x3c00
addl 0x8(%r15), %eax
cmpl %eax, %r12d
jmp 0x3c0d
cmpl %eax, %r12d
setne %al
cmpl %r14d, %ebx
setl %cl
orb %al, %cl
je 0x3c04
xorl %eax, %eax
jmp 0x3c10
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_O1/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 0x8edc(%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 0x3804
addq $0x8, %rbx
cmpq $0x4b0, %rbx            # imm = 0x4B0
jne 0x3c5d
movq -0x38(%rbp), %rax
movq %r14, 0x8(%rax)
movaps 0x53a0(%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_O1/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 0x3d5c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
cmpl $0x0, 0x14(%rdi)
setg %al
jle 0x3d61
movq %rsi, %rbx
movl 0x18(%r14), %r15d
xorl %r12d, %r12d
movslq %r15d, %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x38a0
testb %al, %al
jne 0x3d5f
movl 0x10(%r14), %ecx
leal (%r15,%rcx), %eax
decl %eax
cltd
idivl %ecx
incl %r12d
movl %edx, %r15d
cmpl 0x14(%r14), %r12d
setl %al
jl 0x3d27
jmp 0x3d61
xorl %eax, %eax
retq
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3db2
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 0x38a0
testb %al, %al
je 0x3db5
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 0x3db7
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_O1/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:
cmpl $0x0, 0x24(%rdi)
je 0x40c6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x0, (%rdx)
setg %al
jle 0x407a
movq %rsi, %r15
movb %al, -0x29(%rbp)
movslq 0x18(%rbx), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x3b12
testb %al, %al
jne 0x4068
addq $0x18, %r15
xorl %r13d, %r13d
incq %r13
movslq (%r12), %rax
cmpq %rax, %r13
setl %al
jge 0x407a
movb %al, -0x29(%rbp)
leaq 0x18(%r15), %r14
movslq 0x18(%rbx), %rsi
shlq $0x3, %rsi
addq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x3b12
movq %r14, %r15
testb %al, %al
je 0x4037
decl 0x24(%rbx)
addl $0xfffffc18, 0x20(%rbx) # imm = 0xFFFFFC18
movb $0x1, %al
cmpb $0x0, -0x29(%rbp)
jne 0x40d5
cmpl $0x4, 0x14(%rbx)
setge %al
jl 0x40d5
movl 0x1c(%rbx), %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movslq 0x18(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
movslq %r14d, %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x38a0
testb %al, %al
jne 0x40c9
incl %r14d
movl %r14d, %eax
cltd
idivl 0x10(%rbx)
incl %r15d
movl 0x14(%rbx), %eax
addl $-0x3, %eax
movl %edx, %r14d
cmpl %eax, %r15d
setl %al
jl 0x408a
jmp 0x40d5
xorl %eax, %eax
retq
decl 0x24(%rbx)
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_O1/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 0x468a
decl %eax
movl %eax, 0x24(%rdi)
jne 0x468a
movb $0x0, 0x3c(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a9a
movq %rdi, %rbx
movw $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpb $0x1, 0x3d(%rdi)
jne 0x4a06
movq %rbx, %rdi
callq 0x40e4
movsbl 0x28(%rbx), %edx
leaq 0x473c(%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 0x4aa2
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 0x4a9f
xorl %r14d, %r14d
cmpb $0x4f, -0x28(%rbp)
jne 0x4aa2
cmpb $0x4b, -0x27(%rbp)
je 0x4a9a
jmp 0x4aa2
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 0x4aa2
cmpb $0x4d, -0x28(%rbp)
jne 0x4aa2
movzbl -0x27(%rbp), %eax
movb %al, 0x28(%rbx)
xorl %r14d, %r14d
cmpl $0x51, %eax
jg 0x4a4b
cmpl $0x44, %eax
je 0x4a5c
cmpl $0x4c, %eax
jne 0x4aa2
movl $0x104, %edi            # imm = 0x104
jmp 0x4a68
cmpl $0x52, %eax
je 0x4a63
movl $0x103, %edi            # imm = 0x103
cmpl $0x55, %eax
je 0x4a68
jmp 0x4aa2
movl $0x102, %edi            # imm = 0x102
jmp 0x4a68
movl $0x105, %edi            # imm = 0x105
callq 0x3350
movq %rbx, %rdi
callq 0x40e4
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 0x4a9f
movb $0x1, %r14b
jmp 0x4aa2
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matallui[P]nibble-curses/src/CSocket.cpp
// Function: CSocket::Recv(char*, int const&)
bool CSocket::Recv ( char * buffer, int const & buffsize )
{
  if ( !m_connected ) return false;
  
  bzero ( buffer, buffsize );
  int n;
  n = read ( m_newsockfd, buffer, buffsize );
  if ( n < 0 ) return false;
  return true;
}

// Assembly:
cmpb $0x1, 0x20(%rdi)
jne 0x4b55
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movslq (%rdx), %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3180
movl 0x8(%r15), %edi
movslq (%r14), %rdx
movq %rbx, %rsi
callq 0x3370
testl %eax, %eax
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c51
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
setns %r14b
js 0x4c51
movl 0x24(%rbx), %edi
movl $0x5, %esi
callq 0x32b0
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c8b
movb $0x1, 0x20(%rbx)
testl %eax, %eax
setns %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d62
movq %r15, %rdi
callq 0x32d0
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x4d5f
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 0x4d62
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matallui[P]nibble-curses/src/CSocketClient.cpp
// Function: CSocketClient::EstablishConnection()
bool CSocketClient::EstablishConnection ( void )
{
  int s;
  s = connect ( m_newsockfd, (struct sockaddr*) (&m_serverAddr), sizeof(m_serverAddr) );
  if ( s < 0 ) return false;
  m_connected = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
leaq 0x10(%rbx), %rsi
movl $0x10, %edx
callq 0x3210
testl %eax, %eax
js 0x4d92
movb $0x1, 0x20(%rbx)
testl %eax, %eax
setns %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5030
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
cmpq $0x1, %r14
je 0x501d
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x5047
callq 0x3340
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x5055
callq 0x3340
cmpl $0x3, 0x14(%rbx)
jne 0x506a
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x506a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x7f5f(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3190
callq 0x3300
cmpl $0x5, 0x24(%rbx)
jne 0x5122
movq 0x7f47(%rip), %r14      # 0xcfd8
leaq 0x4187(%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 0x7f15(%rip), %rdi      # 0xcfd8
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x7f01(%rip), %rdi      # 0xcfd8
leaq 0x4163(%rip), %rsi      # 0x9241
movl $0x3, %edx
callq 0x32e0
leaq 0x50(%rbx), %rsi
movq 0x7ee5(%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 0x513e
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3280
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x4b58
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52d8
movl $0x2, 0x24(%rbx)
movl $0x1, 0x8(%rbx)
movabsq $0x200000000, %r14      # imm = 0x200000000
movq %rbx, %rdi
callq 0x5e44
movl $0x0, 0x24(%rbx)
movq %rbx, %rdi
callq 0x6776
testb %al, %al
je 0x519e
movl 0x1c(%rbx), %edi
callq 0x3360
jmp 0x5188
movl 0x24(%rbx), %eax
cmpl $0x3, %eax
je 0x51b2
cmpl $0x1, %eax
jne 0x51ea
movl 0x8(%rbx), %eax
decl %eax
jmp 0x51e7
movq %rbx, %rdi
callq 0x6a96
testb %al, %al
je 0x523c
cmpl $0x0, 0x10(%rbx)
jle 0x51e1
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 0x51c7
movq %r14, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
cmpl $0xa, 0x8(%rbx)
jne 0x522a
movq %rbx, %rdi
callq 0x700e
testb %al, %al
je 0x523c
cmpl $0x0, 0x10(%rbx)
jle 0x521f
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 0x5205
movq %r14, 0x20(%rbx)
movl $0x0, 0x8(%rbx)
movl 0x8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
cmpl $0xa, %eax
jl 0x5179
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x524f
jmp 0x524f
jmp 0x524f
jmp 0x524f
movq %rax, %r14
cmpl $0x1, %edx
jne 0x52c8
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 0x52a0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3280
callq 0x33c0
jmp 0x523c
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52c3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3280
callq 0x33c0
movq %r14, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x4b58