LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: mapnotify
void mapnotify(xcb_generic_event_t *e)
{
    xcb_map_notify_event_t *ev = (xcb_map_notify_event_t *)e;

    DEBUG("xcb: map notify");

    if (wintoclient(ev->window))
        return;

    xcb_window_t wins[] = {ev->window};
    xcb_get_window_attributes_reply_t *attr[1];

    xcb_get_attributes(wins, attr, 1);
    if (!attr[0])
        return;     /* dead on arrival */
    if (attr[0]->override_redirect) {
        free(attr[0]);
        return;
    }
    else
        free(attr[0]);

    if (wintoalien(&aliens, ev->window)) {
        DEBUG("alien window already in list");
        return;
    }

    xcb_ewmh_get_atoms_reply_t type;
    if (xcb_ewmh_get_wm_window_type_reply(ewmh,
                                xcb_ewmh_get_wm_window_type(ewmh,
                                ev->window), &type, NULL) == 1) {
        create_alien(ev->window, type.atoms[0]);
        xcb_ewmh_get_atoms_reply_wipe(&type);
        DEBUG("caught a new selfmapped window");
    }
    else {
        DEBUG("alien has no _NET_WM_WINDOW_TYPE property");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl %ebp, %edi
callq 0x6c8f
testq %rax, %rax
je 0x5a90
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x5cb9(%rip), %rdi      # 0xb750
movl %ebp, %esi
callq 0x33e0
movq 0x5cab(%rip), %rdi      # 0xb750
movl %eax, %esi
xorl %edx, %edx
callq 0x3230
testq %rax, %rax
je 0x5a87
movb 0x1b(%rax), %bpl
movq %rax, %rdi
callq 0x3050
testb %bpl, %bpl
jne 0x5a87
movl 0x8(%rbx), %esi
testl %esi, %esi
sete %cl
movq 0x5cbd(%rip), %rax      # 0xb790
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x5aeb
cmpl %esi, 0x18(%rax)
je 0x5a87
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x5add
movq 0x5c76(%rip), %r14      # 0xb768
movq %r14, %rdi
callq 0x3570
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x35e0
cmpb $0x1, %al
jne 0x5a87
movl 0x8(%rbx), %edi
leaq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rax
movl (%rax), %esi
callq 0x706d
movq %rbx, %rdi
callq 0x3040
jmp 0x5a87
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: propertynotify
void propertynotify(xcb_generic_event_t *e)
{
    xcb_property_notify_event_t *ev = (xcb_property_notify_event_t *)e;
    xcb_icccm_wm_hints_t wmh;
    client *c;

    DEBUG("xcb: property notify");

#ifdef EWMH_TASKBAR
    if (ev->atom == ewmh->_NET_WM_STRUT
     || ev->atom == ewmh->_NET_WM_STRUT_PARTIAL) {
        tile();
        return;
    }
#endif /* EWMH_TASKBAR */

    c = wintoclient(ev->window);
    if (!c || ev->atom != XCB_ICCCM_WM_ALL_HINTS)
        return;
    DEBUG("xcb: got hint!");
    if (xcb_icccm_get_wm_hints_reply(dis,
                                     xcb_icccm_get_wm_hints(dis, ev->window),
                                                            &wmh, NULL))
                                     /* TODO: error handling */
        c->isurgent = c != M_CURRENT &&
                           (wmh.flags & XCB_ICCCM_WM_HINT_X_URGENCY);
    desktopinfo();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movl 0x4(%rdi), %ebp
movl %ebp, %edi
callq 0x6c8f
testq %rax, %rax
je 0x5fc2
cmpl $0x7f, 0x8(%r14)
jne 0x5fc2
movq %rax, %rbx
movq 0x57cf(%rip), %r14      # 0xb750
movq %r14, %rdi
movl %ebp, %esi
callq 0x3030
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x3640
testb %al, %al
je 0x5fbd
movq 0x57d9(%rip), %rax      # 0xb780
cmpq 0x30(%rax), %rbx
setne %al
movl 0xc(%rsp), %ecx
shrl $0x8, %ecx
andl $0x1, %ecx
andb %al, %cl
movb %cl, 0x18(%rbx)
callq 0x4e44
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: unmapnotify
void unmapnotify(xcb_generic_event_t *e)
{
    xcb_unmap_notify_event_t *ev = (xcb_unmap_notify_event_t *)e;
    client *c = wintoclient(ev->window);

    DEBUG("xcb: unmap notify");

    if (c && on_current_desktop(c)) {
        if (c->isfullscreen)
            destroy_display(c);
        removeclient(c);
        desktopinfo();
    }
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %edi
callq 0x6c8f
testq %rax, %rax
je 0x6019
movq %rax, %rbx
movq 0x579d(%rip), %rcx      # 0xb780
addq $0x18, %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x5ff8
leaq 0x8(%rax), %rcx
cmpq %rbx, %rax
jne 0x5fe7
testq %rax, %rax
je 0x6019
cmpb $0x1, 0x1b(%rbx)
jne 0x600b
movq %rbx, %rdi
callq 0x3cab
movq %rbx, %rdi
callq 0x6c09
popq %rbx
jmp 0x4e44
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: addwindow
client *addwindow(xcb_window_t win, xcb_atom_t wtype)
{
    client *c = create_client(win, wtype);

/* c is valid, else we would not get here */
    if (!check_head(&current_display->clients)) {
        add_head(&current_display->clients, &c->link);
    }
    else {
        if (!ATTACH_ASIDE)
            add_head(&current_display->clients, &c->link);
        else
            add_tail(&current_display->clients, &c->link);
    }
    DEBUG("client added");
    setwindefattr(win);
    return c;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %r14d
movl %edi, %ebp
movl $0x1, %edi
movl $0x48, %esi
callq 0x3300
testq %rax, %rax
je 0x624c
movq %rax, %rbx
movb $0x0, 0x1c(%rax)
movl $0x0, 0x18(%rax)
movl %ebp, 0x20(%rax)
movl %r14d, 0x24(%rax)
movq $0x0, 0x28(%rax)
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movb $0x1, 0x44(%rax)
movq 0x55b0(%rip), %r14      # 0xb750
movq %r14, %rdi
movl %ebp, %esi
callq 0x3030
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x3640
testb %al, %al
je 0x61c8
cmpl $0x0, 0x10(%rsp)
setne 0x44(%rbx)
movl 0x20(%rbx), %ebp
movq 0x557e(%rip), %r14      # 0xb750
movq %r14, %rdi
movl %ebp, %esi
callq 0x33b0
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x3240
testq %rax, %rax
je 0x625f
movswl 0xc(%rax), %ecx
movl %ecx, 0x38(%rbx)
movl %ecx, 0x30(%rbx)
movswl 0xe(%rax), %ecx
movl %ecx, 0x3c(%rbx)
movl %ecx, 0x34(%rbx)
movq %rax, %rdi
callq 0x3050
movq 0x5570(%rip), %rcx      # 0xb780
leaq 0x18(%rcx), %rax
cmpq $0x0, 0x18(%rcx)
je 0x6234
movq 0x20(%rcx), %rdx
movq %rbx, 0x20(%rcx)
movq %rbx, 0x8(%rdx)
movq %rdx, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x623c
movq %rbx, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1fec(%rip), %rsi      # 0x823f
movl $0x1, %edi
xorl %eax, %eax
callq 0x3400
leaq 0x1fb4(%rip), %rsi      # 0x821a
movl $0x1, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: grabbuttons
void grabbuttons(client *c)
{
    unsigned int modifiers[] = { 0, XCB_MOD_MASK_LOCK, numlockmask,
                                 numlockmask|XCB_MOD_MASK_LOCK };
    if (!c)
        return;

    xcb_ungrab_button(dis, XCB_BUTTON_INDEX_ANY, c->win, XCB_GRAB_ANY);
    for (unsigned int b = 0; b < LENGTH(buttons); b++)
        for (unsigned int m = 0; m < LENGTH(modifiers); m++)
            if (CLICK_TO_FOCUS)
                xcb_grab_button(dis, 1, c->win, XCB_EVENT_MASK_BUTTON_PRESS,
                                XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC,
                                XCB_WINDOW_NONE, XCB_CURSOR_NONE,
                                XCB_BUTTON_INDEX_ANY, XCB_BUTTON_MASK_ANY);
            else
                xcb_grab_button(dis, 1, c->win, XCB_EVENT_MASK_BUTTON_PRESS,
                                XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC,
                                XCB_WINDOW_NONE, XCB_CURSOR_NONE,
                                buttons[b].button,
                                buttons[b].mask|modifiers[m]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x54cb(%rip), %rdi      # 0xb750
movl 0x20(%rbx), %edx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x34d0
xorl %ebp, %ebp
movl $0x4, %r15d
movq 0x54ad(%rip), %rdi      # 0xb750
movl 0x20(%rbx), %edx
movl $0x1, %esi
movl $0x4, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq $0x8000                 # imm = 0x8000
pushq %r14
pushq %r14
pushq %r14
callq 0x3320
addq $0x20, %rsp
decl %r15d
jne 0x629c
incl %ebp
cmpl $0x5, %ebp
jne 0x6296
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: switch_mode
void switch_mode(const Arg *arg)
{
    if (M_MODE == arg->i)
        for (client *c = M_HEAD; c; c = M_GETNEXT(c))
            unfloat_client(c);
    M_MODE = arg->i;
    tile();
    update_current(M_CURRENT);
    desktopinfo();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x52bd(%rip), %rax      # 0xb780
movl 0x5c(%rax), %ecx
cmpl (%rdi), %ecx
jne 0x651c
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x651c
movb $0x0, 0x1a(%r15)
movl 0x20(%r15), %ebp
movq 0x526d(%rip), %r14      # 0xb750
movq %r14, %rdi
movl %ebp, %esi
callq 0x33b0
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x3240
testq %rax, %rax
je 0x654c
movzwl 0x10(%rax), %ecx
movl %ecx, 0x28(%r15)
movzwl 0x12(%rax), %ecx
movl %ecx, 0x2c(%r15)
movq %rax, %rdi
callq 0x3050
movq 0x8(%r15), %r15
jmp 0x64ce
movl (%rbx), %eax
movq 0x525b(%rip), %rcx      # 0xb780
movl %eax, 0x5c(%rcx)
callq 0x5013
movq 0x524c(%rip), %rax      # 0xb780
movq 0x30(%rax), %rdi
callq 0x3dcb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e44
leaq 0x1cc7(%rip), %rsi      # 0x821a
movl $0x1, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: spawn
void spawn(const Arg *arg)
{
    if (fork())
        return;
    if (dis)
        close(screen->root);
    setsid();
    execvp((char *)arg->com[0], (char **)arg->com);
    err(EXIT_SUCCESS, "error: execvp %s", (char *)arg->com[0]);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3660
testl %eax, %eax
je 0x65b2
popq %rbx
retq
cmpq $0x0, 0x5196(%rip)      # 0xb750
je 0x65ca
movq 0x51ad(%rip), %rax      # 0xb770
movl (%rax), %edi
callq 0x32a0
callq 0x32d0
movq (%rbx), %rsi
movq (%rsi), %rdi
callq 0x3580
movq (%rbx), %rax
movq (%rax), %rdx
leaq 0x1c1c(%rip), %rsi      # 0x8203
xorl %edi, %edi
xorl %eax, %eax
callq 0x3400
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: client_to_desktop
void client_to_desktop(const Arg *arg)
{
    if (!M_CURRENT || arg->i == current_desktop_number || arg->i > DESKTOPS-1)
        return;
    int cd = current_desktop_number;
    client *c = M_CURRENT;

    rem_node(&c->link);
    select_desktop(arg->i);
    add_tail(&current_display->clients, &c->link);
    select_desktop(cd);
    xcb_move(dis, c->win, -2 * M_WW, 0, &c->position_info);
    xcb_ewmh_set_wm_desktop(ewmh, c->win, arg->i);

    if (FOLLOW_WINDOW)
        change_desktop(arg);
    else
        update_current(M_PREVFOCUS);

    desktopinfo();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x5181(%rip), %rax      # 0xb780
movq 0x30(%rax), %r14
testq %r14, %r14
je 0x66e0
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x5191(%rip), %ebp      # 0xb7a8
cmpl %ebp, %eax
sete %cl
cmpl $0xa, %eax
setge %al
orb %cl, %al
jne 0x66e0
movq %r14, %rdi
callq 0x4f4a
movl (%rbx), %edi
callq 0x4fc0
movq 0x5140(%rip), %rcx      # 0xb780
leaq 0x18(%rcx), %rax
cmpq $0x0, 0x18(%rcx)
je 0x6663
movq 0x20(%rcx), %rdx
movq %r14, 0x20(%rcx)
movq %r14, 0x8(%rdx)
movq %rdx, (%r14)
movl $0x8, %ecx
xorl %edx, %edx
jmp 0x6673
movq %r14, 0x18(%rcx)
movq %r14, 0x20(%rcx)
movl $0x10, %ecx
movq %rax, %rdx
movq %rdx, (%r14,%rcx)
movq %rax, 0x10(%r14)
movl %ebp, %edi
callq 0x4fc0
movq 0x50c7(%rip), %rdi      # 0xb750
movl 0x20(%r14), %esi
movq 0x50f4(%rip), %rax      # 0xb788
movl 0x34(%rax), %eax
addl %eax, %eax
negl %eax
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
xorl %edx, %edx
movl %edx, 0x4(%rcx)
movq 0x38(%r14), %r8
movq %r8, 0x30(%r14)
movl %eax, 0x38(%r14)
movl %edx, 0x3c(%r14)
movl $0x3, %edx
callq 0x32c0
movq 0x50a0(%rip), %rdi      # 0xb768
movl 0x20(%r14), %esi
movl (%rbx), %edx
callq 0x3650
movq %rbx, %rdi
callq 0x62e4
callq 0x4e44
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: next_win
void next_win()
{
    client *t = M_CURRENT;

    if (!M_CURRENT || !M_GETNEXT(M_HEAD))
        return;

    while (1) {
        if (!M_GETNEXT(t))
            t = M_HEAD;
        else
            t = M_GETNEXT(t);
        if (!t->isminimized)
            break;
        if (t == M_CURRENT)
            break;
    }

    M_PREVFOCUS = M_CURRENT;
    update_current(t);
}

// Assembly:
movq 0x5080(%rip), %rax      # 0xb780
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x6749
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x6749
cmpq $0x0, 0x8(%rdx)
je 0x6749
movq %rcx, %rsi
movq %rdx, %rdi
testq %rsi, %rsi
je 0x6732
cmpq $0x0, 0x8(%rsi)
movq %rdx, %rdi
je 0x6732
movq 0x8(%rsi), %rdi
cmpq %rcx, %rdi
je 0x6740
cmpb $0x0, 0x1d(%rdi)
movq %rdi, %rsi
jne 0x671c
movq %rcx, 0x38(%rax)
jmp 0x3dcb
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: prev_win
void prev_win()
{
    client *t = M_CURRENT;

    if (!M_CURRENT || !M_GETNEXT(M_HEAD))
        return;

    for (;;) {
        if(!(t = M_GETPREV(t)))
            t = M_TAIL;
        if (!t->isminimized)
            break;
        if (t == M_CURRENT)
            break;
    }

    M_PREVFOCUS = M_CURRENT;
    update_current(t);
}

// Assembly:
movq 0x502f(%rip), %rax      # 0xb780
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x6796
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x6796
cmpq $0x0, 0x8(%rdx)
je 0x6796
movq %rcx, %rdi
testq %rdi, %rdi
je 0x6777
movq (%rdi), %rdi
jmp 0x6779
xorl %edi, %edi
testq %rdi, %rdi
jne 0x6782
movq 0x20(%rax), %rdi
cmpq %rcx, %rdi
je 0x678d
cmpb $0x0, 0x1d(%rdi)
jne 0x676d
movq %rcx, 0x38(%rax)
jmp 0x3dcb
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: move_down
void move_down()
{
    if (!M_CURRENT || !M_GETNEXT(M_CURRENT))
        return;
    client *c = M_CURRENT;
    client *n = M_GETNEXT(c);
    list   *l = c->link.parent;
    rem_node(&c->link);
    insert_node_after(l, &n->link, &c->link);
    tile();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4fdd(%rip), %rax      # 0xb780
movq 0x30(%rax), %rbx
testq %rbx, %rbx
je 0x67e1
cmpq $0x0, 0x8(%rbx)
je 0x67e1
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x4f4a
testq %r15, %r15
je 0x67e7
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x67e7
movq %rbx, 0x8(%r15)
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, (%rax)
jmp 0x6815
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, (%r14)
je 0x6806
movq 0x8(%r14), %rax
movq %rbx, 0x8(%r14)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x6811
movq %rbx, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, 0x10(%rbx)
movq %r14, 0x10(%rbx)
movq %r14, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
jmp 0x5013
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: move_up
void move_up()
{
    if (!M_CURRENT || !M_GETPREV(M_CURRENT))
        return;
    client *c = M_CURRENT;
    client *p = M_GETPREV(c);
    list   *l = c->link.parent;
    rem_node(&c->link);
    insert_node_before(l, &p->link, &c->link);
    tile();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4f51(%rip), %rax      # 0xb780
movq 0x30(%rax), %rbx
testq %rbx, %rbx
je 0x686a
cmpq $0x0, (%rbx)
je 0x686a
movq (%rbx), %r15
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x4f4a
testq %r15, %r15
je 0x6870
movq (%r15), %rax
testq %rax, %rax
je 0x6870
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, (%r15)
jmp 0x6893
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq %rbx, (%r14)
testq %rax, %rax
je 0x6888
movq $0x0, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x688c
leaq 0x8(%r14), %rax
movq %rbx, (%rax)
movq %r14, 0x10(%rbx)
movq %r14, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
jmp 0x5013
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: swap_master
void swap_master()
{
    if (!M_CURRENT || !M_GETNEXT(M_HEAD))
        return;
    if (M_CURRENT == M_HEAD) {
        client *c = M_GETNEXT(M_HEAD);
        rem_node(&c->link);
        add_head(&current_display->clients, &c->link);
    }
    else {
        client *c = M_CURRENT;
        rem_node(&c->link);
        add_head(&current_display->clients, &c->link);
    }
    update_current(M_HEAD);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4ed3(%rip), %r15      # 0xb780
movq 0x30(%r15), %rbx
testq %rbx, %rbx
je 0x68ef
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x68ef
cmpq $0x0, 0x8(%rax)
je 0x68ef
cmpq %rax, %rbx
je 0x68f5
leaq 0x18(%r15), %r14
movq %rbx, %rdi
callq 0x4f4a
movq (%r14), %rax
movq %rbx, (%r14)
testq %rax, %rax
je 0x6900
movq $0x0, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x693c
popq %rbx
popq %r14
popq %r15
retq
testq %rax, %rax
je 0x6909
movq 0x8(%rax), %rbx
jmp 0x690b
addq $0x20, %r15
movq %r15, %rax
jmp 0x693c
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x4f4a
movq 0x4e66(%rip), %r14      # 0xb780
movq 0x18(%r14), %rax
movq %rbx, 0x18(%r14)
testq %rax, %rax
je 0x6934
movq $0x0, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x6938
leaq 0x20(%r14), %rax
addq $0x18, %r14
movq %rbx, (%rax)
movq %r14, 0x10(%rbx)
movq 0x4e36(%rip), %rax      # 0xb780
movq 0x18(%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3dcb
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: setmaximize
void setmaximize(client *c, bool maximize)
{
    DEBUGP("xcb: set maximize: %d\n", maximize);

    if (!c || c->isfullscreen)
        return;

    int borders = client_borders(c);
    borders = 0;
    xcb_border_width(dis, c->win, borders);

    if (maximize) {
        xcb_move_resize(dis, c->win, M_GAPS, M_WY + M_GAPS + PANEL_HEIGHT,
                        M_WW - 2 * (borders + M_GAPS),
                        M_WH - 2 * (borders + M_GAPS), &c->position_info);
        c->ismaximized = True;
    }
    else
        c->ismaximized = False;

    update_current(c);
}

// Assembly:
testq %rdi, %rdi
je 0x6a23
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x1b(%rdi)
jne 0x6a1d
movl %esi, %ebp
movq 0x4db9(%rip), %rdi      # 0xb750
movl 0x20(%rbx), %esi
movq %rsp, %rcx
movl $0x0, (%rcx)
movl $0x10, %edx
callq 0x32c0
testb %bpl, %bpl
je 0x6a10
movq 0x4d97(%rip), %rdi      # 0xb750
movl 0x20(%rbx), %esi
movq 0x4dbd(%rip), %rax      # 0xb780
movl 0x64(%rax), %eax
movq 0x4dbb(%rip), %rcx      # 0xb788
movl 0x3c(%rcx), %edx
addl %eax, %edx
leal (%rax,%rax), %r8d
movl 0x34(%rcx), %r9d
movl 0x38(%rcx), %r10d
subl %r8d, %r9d
subl %r8d, %r10d
movq %rsp, %rcx
movl %eax, (%rcx)
movl %edx, 0x4(%rcx)
movl %r9d, 0x8(%rcx)
movl %r10d, 0xc(%rcx)
movq 0x38(%rbx), %r8
movq %r8, 0x30(%rbx)
movl %eax, 0x38(%rbx)
movl %edx, 0x3c(%rbx)
movl $0xf, %edx
callq 0x32c0
movb $0x1, %al
jmp 0x6a12
xorl %eax, %eax
movb %al, 0x1c(%rbx)
movq %rbx, %rdi
callq 0x3dcb
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: killclient
void killclient()
{
	int n = 0;
	client *c = NULL, *t = NULL;

    if (!M_CURRENT)
        return;
    if (!deletewindow(M_CURRENT->win)) {
        xcb_kill_client(dis, M_CURRENT->win);
        DEBUG("client killed");
    }
    else {
        DEBUG("client deleted");
    }
    /* this section is for switching to previous (-1) desktop when the last window on it is killed */
    /* count stack windows and grab first non-floating, non-maximize window */
    for (t = M_HEAD; t; t = M_GETNEXT(t)) {
        if (!ISFMTM(t)) {
            if (c)
                ++n;
            else
                c = t;
        }
    }
	/* just this line below was the original piece of code */
	removeclient(M_CURRENT);
	while (n < 1) {
		if (current_desktop_number == 0)
			return;
		change_desktop(&(Arg)
			{.i = (DESKTOPS + current_desktop_number - 1) % DESKTOPS});
		n = 0;
		/* count stack windows and grab first non-floating, non-maximize window */
		for (t = M_HEAD; t; t = M_GETNEXT(t)) {
			if (!ISFMTM(t)) {
				if (c)
					++n;
				else
					c = t;
			}
		}
	}

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x4ccd(%rip), %rax      # 0xb780
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x6c01
movl 0x20(%rax), %edi
movl 0x4d1b(%rip), %esi      # 0xb7e4
callq 0x503b
testb %al, %al
jne 0x6aec
movq 0x4c77(%rip), %rdi      # 0xb750
movq 0x4ca0(%rip), %rax      # 0xb780
movq 0x30(%rax), %rax
movl 0x20(%rax), %esi
callq 0x35f0
movq 0x4c8d(%rip), %rax      # 0xb780
movq 0x18(%rax), %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x6b4a
movq 0x4c63(%rip), %rsi      # 0xb768
xorl %r14d, %r14d
cmpb $0x0, 0x1b(%rdx)
jne 0x6b3a
cmpb $0x0, 0x1c(%rdx)
jne 0x6b3a
cmpb $0x0, 0x19(%rdx)
jne 0x6b3a
cmpb $0x0, 0x1d(%rdx)
jne 0x6b3a
movl 0x24(%rdx), %edi
cmpl 0x104(%rsi), %edi
jne 0x6b3a
xorl %edi, %edi
testq %r14, %r14
setne %dil
cmoveq %rdx, %r14
addl %edi, %ecx
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0x6b08
testl %ecx, %ecx
setle %bl
jmp 0x6b4f
movb $0x1, %bl
xorl %r14d, %r14d
movq 0x30(%rax), %rdi
callq 0x6c09
testb %bl, %bl
je 0x6c01
movq %rsp, %rbx
movl 0x4c3f(%rip), %eax      # 0xb7a8
testl %eax, %eax
je 0x6c01
addl $0x9, %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, (%rsp)
movq %rbx, %rdi
callq 0x62e4
movq 0x4bdd(%rip), %rax      # 0xb780
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x6bf7
xorl %ecx, %ecx
movq 0x4bb3(%rip), %rdx      # 0xb768
cmpb $0x0, 0x1b(%rax)
jne 0x6be7
cmpb $0x0, 0x1c(%rax)
jne 0x6be7
cmpb $0x0, 0x19(%rax)
jne 0x6be7
cmpb $0x0, 0x1d(%rax)
jne 0x6be7
movl 0x24(%rax), %esi
cmpl 0x104(%rdx), %esi
jne 0x6be7
xorl %esi, %esi
testq %r14, %r14
setne %sil
cmoveq %rax, %r14
addl %esi, %ecx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x6bb5
testl %ecx, %ecx
setle %al
jmp 0x6bf9
movb $0x1, %al
testb %al, %al
jne 0x6b63
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: removeclient
void removeclient(client *c)
{
    int nd = 0, cd = current_desktop_number;

    if (!c)
        return;
    rem_node(&c->link);
    if (c == M_PREVFOCUS)
        M_PREVFOCUS = M_GETPREV(M_CURRENT);
    if (c == M_CURRENT || !M_GETNEXT(M_HEAD))
        update_current(M_PREVFOCUS);
    free(c);
    c = NULL;
    if (cd == nd - 1)
        tile();
    else
        select_desktop(cd);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6c3b
movq %rdi, %r14
movl 0x4b8d(%rip), %ebx      # 0xb7a8
callq 0x4f4a
movq 0x4b59(%rip), %rax      # 0xb780
cmpq %r14, 0x38(%rax)
jne 0x6c49
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x6c43
movq (%rcx), %rcx
jmp 0x6c45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ecx, %ecx
movq %rcx, 0x38(%rax)
cmpq %r14, 0x30(%rax)
je 0x6c5f
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x6c5f
cmpq $0x0, 0x8(%rcx)
jne 0x6c68
movq 0x38(%rax), %rdi
callq 0x3dcb
movq %r14, %rdi
callq 0x3050
cmpl $-0x1, %ebx
je 0x6c83
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4fc0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5013
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: wintoclient
client *wintoclient(xcb_window_t win)
{
    desktop *desk;
    for (desk = (desktop *)get_head(&desktops); desk; desk = (desktop *)get_next(&desk->link)) {
        monitor *moni;
        for (moni = (monitor *)get_head(&desk->monitors); moni; moni = (monitor *)get_next(&moni->link)) {
            display *disp;
            for (disp = (display *)get_head(&moni->displays); disp; disp = (display *)get_next(&disp->link)) {
                client *c;
                for (c = (client *)get_head(&disp->clients); c; c = (client *)get_next(&c->link)) {
                    if (c->win == win) {
                        return c;
                    }
                }
            }
        }
    }
    return NULL;
}

// Assembly:
movq 0x4b22(%rip), %rcx      # 0xb7b8
testq %rcx, %rcx
je 0x6cf7
movq 0x18(%rcx), %rsi
testq %rsi, %rsi
sete %dl
je 0x6ce9
movq 0x18(%rsi), %r8
movq %rax, %r10
testq %r8, %r8
sete %r9b
je 0x6cdd
movq 0x18(%r8), %rax
testq %rax, %rax
sete %r11b
je 0x6ccf
cmpl %edi, 0x20(%rax)
je 0x6cd2
movq 0x8(%rax), %rax
jmp 0x6cbb
movq %r10, %rax
testb %r11b, %r11b
je 0x6cdd
movq 0x8(%r8), %r8
jmp 0x6cab
testb $0x1, %r9b
je 0x6ce9
movq 0x8(%rsi), %rsi
jmp 0x6c9f
testb $0x1, %dl
je 0x6cf9
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x6c9b
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: resize_master
void resize_master(const Arg *arg)
{
    int msz = M_WW * MASTER_SIZE + M_MASTER_SIZE + arg->i;

    if (msz < MINWSZ || M_WW - msz < MINWSZ)
        return;
    M_MASTER_SIZE += arg->i;
    tile();
}

// Assembly:
movq 0x4779(%rip), %rax      # 0xb788
movl 0x34(%rax), %edx
cvtsi2sd %edx, %xmm1
movq 0x4763(%rip), %rax      # 0xb780
movss 0x58(%rax), %xmm0
cvtss2sd %xmm0, %xmm2
mulsd 0xfda(%rip), %xmm1      # 0x8008
addsd %xmm2, %xmm1
movl (%rdi), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %esi
cmpl $0x32, %esi
setl %dil
subl %esi, %edx
cmpl $0x32, %edx
setl %dl
orb %dil, %dl
je 0x7058
retq
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x58(%rax)
jmp 0x5013
// File: /workspace/github_c_makefile_star2_O1/kaugm[P]mmwm/mmwm.c
// Function: create_alien
static inline alien *create_alien(xcb_window_t win, xcb_atom_t atom)
{
    alien *a;
    if((a = (alien *)calloc(1, sizeof(alien)))) {
        unsigned int values[1] = { XCB_EVENT_MASK_PROPERTY_CHANGE };
        xcb_change_window_attributes(dis, win, XCB_CW_EVENT_MASK, values);
        a->win = win;
        a->type = atom;
        add_tail(&aliens, &a->link);
        xcb_raise_window(dis, win);
        xcb_map_window(dis, win);

        xcb_get_geometry_reply_t *g = get_geometry(a->win);
        a->position_info.previous_x = a->position_info.current_x = g->x;
        a->position_info.previous_y = a->position_info.current_y = g->y;
        free(g);
    }
    return(a);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movl %edi, %ebp
movl $0x1, %edi
movl $0x30, %esi
callq 0x3300
testq %rax, %rax
je 0x7174
movq %rax, %rbx
leaq 0x8(%rsp), %rcx
movl $0x400000, (%rcx)       # imm = 0x400000
movq 0x46a9(%rip), %rdi      # 0xb750
movl %ebp, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x30f0
movl %ebp, 0x18(%rbx)
movl %r14d, 0x1c(%rbx)
cmpq $0x0, 0x46ce(%rip)      # 0xb790
leaq 0x46c7(%rip), %rax      # 0xb790
je 0x70e9
movq 0x46c6(%rip), %rcx      # 0xb798
movq %rbx, 0x46bf(%rip)      # 0xb798
movq %rbx, 0x8(%rcx)
movq %rcx, (%rbx)
movl $0x8, %ecx
xorl %edx, %edx
jmp 0x70ff
movq %rbx, 0x46a0(%rip)      # 0xb790
movq %rbx, 0x46a1(%rip)      # 0xb798
movl $0x10, %ecx
movq %rax, %rdx
movq %rdx, (%rbx,%rcx)
movq %rax, 0x10(%rbx)
movq 0x4642(%rip), %rdi      # 0xb750
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movl %ebp, %esi
movl $0x40, %edx
callq 0x32c0
movq 0x4624(%rip), %rdi      # 0xb750
movl %ebp, %esi
callq 0x34c0
movl 0x18(%rbx), %ebp
movq 0x4613(%rip), %r14      # 0xb750
movq %r14, %rdi
movl %ebp, %esi
callq 0x33b0
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x3240
testq %rax, %rax
je 0x717d
movswl 0xc(%rax), %ecx
movl %ecx, 0x28(%rbx)
movl %ecx, 0x20(%rbx)
movswl 0xe(%rax), %ecx
movl %ecx, 0x2c(%rbx)
movl %ecx, 0x24(%rbx)
movq %rax, %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1096(%rip), %rsi      # 0x821a
movl $0x1, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/5-Signal/alarm_fgets.c
// Function: main
int main(void)
{
	char buf[1024];
	signal(SIGALRM, sig_handler);
	alarm(TIMEOUT);
	if(fgets(buf, 1024, stdin) == NULL)
	{
		printf("No input. Goodbye!\n");
		exit(0);
	}
	alarm(0);
	printf("Your input: %s", buf);
	return 0;
}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
leaq -0x22(%rip), %rsi       # 0x118c
movl $0xe, %edi
callq 0x1070
movl $0x5, %edi
callq 0x1050
movq 0x2e17(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1060
testq %rax, %rax
je 0x1200
xorl %edi, %edi
callq 0x1050
leaq 0xe18(%rip), %rdi       # 0x2004
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
retq
leaq 0xe1f(%rip), %rdi       # 0x2026
callq 0x1030
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/humansize/main.c
// Function: main
int
main(int argc, char * argv[])
{
	size_t i;
	uint64_t size;
	char * s;
	int failures = 0;

	WARNP_INIT;
	(void)argc; /* UNUSED */

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		/* Notify about what we're trying to do. */
		if (!tests[i].bad)
			printf("Parsing \"%s\" as a number of bytes:",
			    tests[i].s);
		else
			printf("Should fail to parse \"%s\" as a number"
			    " of bytes:", tests[i].s);

		/* Try to parse the test string. */
		if (humansize_parse(tests[i].s, &size)) {
			if (!tests[i].bad) {
				printf(" FAILED!\n");
				failures++;
			} else {
				printf(" PASSED!\n");
			}
		} else {
			if (tests[i].bad || tests[i].val != size) {
				printf(" FAILED!\n");
				failures++;
			} else {
				printf(" PASSED!\n");
			}
		}
	}

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		/* Don't try to do anything with the "bad values". */
		if (tests[i].bad)
			continue;

		/* Notify about what we're trying to do. */
		printf("Generating a string for %" PRIu64 ":", tests[i].val);

		/* Generate (and check) a string. */
		s = humansize(tests[i].val);
		if (strcmp(tests[i].canonical, s) == 0)
			printf(" PASSED!\n");
		else {
			printf(" FAILED!\n");
			failures++;
		}
		free(s);
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1394
callq 0x1730
movl $0x10, %r13d
leaq 0x28ef(%rip), %rbp      # 0x3c90
movq %rsp, %rbx
xorl %r14d, %r14d
movl -0x8(%r13,%rbp), %r15d
testl %r15d, %r15d
movq -0x10(%r13,%rbp), %r12
leaq 0xc6c(%rip), %rdi       # 0x2027
leaq 0xc42(%rip), %rax       # 0x2004
cmoveq %rax, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1090
movq %r12, %rdi
movq %rbx, %rsi
callq 0x15c8
testl %eax, %eax
je 0x13f2
testl %r15d, %r15d
je 0x1402
leaq 0xcdd(%rip), %rdi       # 0x20c8
callq 0x1070
jmp 0x1411
testl %r15d, %r15d
jne 0x1402
movq (%r13,%rbp), %rax
cmpq (%rsp), %rax
je 0x13e4
leaq 0xcb6(%rip), %rdi       # 0x20bf
callq 0x1070
incl %r14d
addq $0x20, %r13
cmpq $0x170, %r13            # imm = 0x170
jne 0x13a7
movl $0x18, %r15d
leaq 0xc2c(%rip), %rbx       # 0x2057
cmpl $0x0, -0x10(%r15,%rbp)
jne 0x1488
movq -0x8(%r15,%rbp), %r12
movq (%r15,%rbp), %r13
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1090
movq %r12, %rdi
callq 0x14ac
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x10d0
testl %eax, %eax
je 0x1474
leaq 0xc55(%rip), %rdi       # 0x20bf
callq 0x1070
incl %r14d
jmp 0x1480
leaq 0xc4d(%rip), %rdi       # 0x20c8
callq 0x1070
movq %r12, %rdi
callq 0x1030
addq $0x20, %r15
cmpq $0x178, %r15            # imm = 0x178
jne 0x142b
xorl %eax, %eax
testl %r14d, %r14d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/omf.cc
// Function: Segment::initDPS()
void Segment::initDPS() {
  kind = 0x12;
  length = 1024;
  resspc = 1024;
  bytecnt = 0;
  name = "Direct";
}

// Assembly:
movw $0x12, 0x10(%rdi)
movl $0x400, 0x8(%rdi)       # imm = 0x400
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, (%rdi)
movq 0x30(%rdi), %rdx
addq $0x28, %rdi
leaq 0x10583(%rip), %rcx     # 0x1723c
movl $0x6, %r8d
xorl %esi, %esi
jmp 0x5360
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/omf.cc
// Function: OMF::load(char const*, unsigned int)
bool OMF::load(const char *filename, uint32_t org) {
  handle = TheHandle::createFromFile(filename);
  if (!handle->isOpen()) {
    return false;
  }

  if (!isOMF()) {
    Segment seg;
    seg.bytecnt = handle->length;
    seg.kind = 0;  // code
    seg.entry = 0;
    seg.mapped = org;
    seg.data = handle;
    seg.length = seg.bytecnt;
    seg.segnum = 1;
    segments.push_back(seg);
  } else {
    if (!loadSegments()) {
      return false;
    }
    if (!mapSegments()) {
      return false;
    }
    if (!relocSegments()) {
      return false;
    }
  }
  std::sort(segments.begin(), segments.end(), compareSegments);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x973c
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x6d1e
callq 0x6752
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d2d
callq 0x6752
movq (%rbx), %rdi
callq 0x98e0
testb %al, %al
je 0x6d65
movq %rbx, %rdi
callq 0x6e74
testb %al, %al
je 0x6d6c
movq %rbx, %rdi
callq 0x6eea
movq %rbx, %rdi
callq 0x7166
movq %rbx, %rdi
callq 0x73e6
testb %al, %al
jne 0x6dfb
xorl %ebx, %ebx
jmp 0x6e52
leaq 0x8(%rbx), %rsi
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq (%rbx), %rax
movl (%rax), %ecx
movl %ecx, -0x38(%r15)
movw $0x0, -0x28(%r15)
movl $0x0, -0x18(%r15)
movl %ebp, 0x28(%r15)
movq %rax, 0x18(%r15)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x7f60
movl -0x58(%r14), %eax
movl %eax, -0x50(%r14)
movw $0x1, -0x3c(%r14)
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x7ea8
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x6de4
callq 0x6752
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6dfb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5230
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %r15
movb $0x1, %bl
cmpq %r15, %r14
je 0x6e52
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq 0xdcb(%rip), %r12       # 0x7c01
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x828f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x83dd
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7ed2
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::hex()
uint32_t File::hex() {
  uint32_t bank = 0;
  uint32_t res = 0;
  if (*p == '$') {
    p++;
  }
  while (p < end && (isxdigit(*p) || *p == '/')) {
    if (*p == '/') {
      bank = res;
      res = 0;
    } else if (isdigit(*p)) {
      res <<= 4;
      res |= *p - '0';
    } else if (*p >= 'a' && *p <= 'f') {
      res <<= 4;
      res |= *p - 'a' + 10;
    } else {
      res <<= 4;
      res |= *p - 'A' + 10;
    }
    p++;
  }
  return res | (bank << 16);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpb $0x24, (%rax)
jne 0xa00a
incq %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
jae 0xa088
xorl %r13d, %r13d
xorl %ebp, %ebp
movzbl (%r15), %r14d
movl %r14d, %edi
callq 0x50d0
cmpl $0x2f, %r14d
je 0xa034
testl %eax, %eax
je 0xa080
xorl %eax, %eax
cmpl $0x2f, %r14d
jne 0xa041
movl %r13d, %ebp
jmp 0xa06f
leal -0x30(%r14), %eax
cmpl $0x9, %eax
ja 0xa053
shll $0x4, %r13d
orl %r13d, %eax
jmp 0xa06f
leal -0x61(%r14), %eax
shll $0x4, %r13d
cmpb $0x5, %al
ja 0xa065
addl $-0x57, %r14d
jmp 0xa069
addl $-0x37, %r14d
orl %r13d, %r14d
movl %r14d, %eax
incq %r15
movq %r15, 0x8(%rbx)
movl %eax, %r13d
cmpq %r12, %r15
jne 0xa01e
jmp 0xa083
movl %r13d, %eax
shll $0x10, %ebp
orl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::check(unsigned char)
bool File::check(uint8_t ch) {
  ws();
  if (p < end && ch == *p) {
    p++;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xa962
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
jae 0xa0c1
cmpb %bpl, (%rax)
jne 0xa0c1
incq %rax
movq %rax, 0x8(%rbx)
movb $0x1, %al
jmp 0xa0c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::oneOf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char File::oneOf(const std::string &str) {
  ws();
  if (p < end && str.find(*p) != std::string::npos) {
    return *p++;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa962
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
jae 0xa10b
movsbl (%rax), %esi
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
callq 0x52b0
cmpq $-0x1, %rax
je 0xa10e
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %r14b
jmp 0xa10e
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::until[abi:cxx11](unsigned char)
std::string File::until(uint8_t ch) {
  std::string r;
  while (*p != ch) {
    r += *p++;
  }
  p++;  // skip ending character
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%r14), %rax
leaq 0x1(%rax), %rcx
cmpb %bpl, (%rax)
movq %rcx, 0x8(%r14)
je 0xa158
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x51f0
jmp 0xa13a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa17c
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: Map::toAddress[abi:cxx11](unsigned int)
std::string Map::toAddress(uint32_t value) {
  static const char *digits = "0123456789abcdef";
  std::string ret="$00/0000";
  for (size_t i = 0, j = 5 << 2; i < 6; i++, j -= 4) {
    ret[i < 2 ? i + 1 : i + 2] = digits[(value >> j) & 0xf];
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xcbac(%rip), %rsi      # 0x17342
leaq 0xcbad(%rip), %rdx      # 0x1734a
callq 0x6952
movl $0x14, %ecx
xorl %edx, %edx
leaq 0xcb81(%rip), %rax      # 0x17331
movl %ebp, %esi
shrl %cl, %esi
andl $0xf, %esi
movb (%rsi,%rax), %sil
leaq 0x2(%rdx), %rdi
cmpq $0x2, %rdx
leaq 0x1(%rdx), %r8
cmovbq %r8, %rdi
movq (%rbx), %rdx
movb %sil, (%rdx,%rdi)
addl $-0x4, %ecx
movq %r8, %rdx
cmpq $0x6, %r8
jne 0xa7b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: Map::addEntry(unsigned int, unsigned int)
void Map::addEntry(uint32_t entry, uint32_t flags) {
  Entry e;
  e.org = entry;
  e.flags = flags;
  entryPoints.push_back(e);
}

// Assembly:
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x10(%rsp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0xa83e
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0xc(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x38(%rdi)
jmp 0xa84c
addq $0x30, %rdi
leaq 0xc(%rsp), %rdx
callq 0xaf74
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::File(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
File::File(const std::string &filename) {
  data = p = nullptr;
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return;
  }
  auto length = f.tellg();
  data = new uint8_t[length];
  f.seekg(0, std::ios::beg);
  f.read(reinterpret_cast<char*>(data), length);
  f.close();
  p = data;
  end = data + length;
  curLine = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
movl $0xe, %edx
callq 0x5390
leaq 0x80(%rsp), %rdi
callq 0x50b0
testb %al, %al
je 0xa91c
leaq 0x8(%rsp), %rdi
callq 0x53d0
movq %rax, %r14
movq %rax, %rdi
callq 0x5030
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52d0
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x5290
leaq 0x8(%rsp), %rdi
callq 0x50a0
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
addq %rax, %r14
movq %r14, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x50e0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0xa945
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x50e0
movq 0x20(%rbx), %rdi
cmpq %r15, %rdi
je 0xa959
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/map.cc
// Function: File::ws()
void File::ws() {
  while (p < end && isspace(*p)) {
    if (*p == '\n') {
      curLine++;
    }
    p++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
jae 0xa9a4
movq %rdi, %rbx
movl 0x18(%rdi), %ebp
movb (%r14), %r12b
movzbl %r12b, %edi
callq 0x5070
testl %eax, %eax
je 0xa9a4
cmpb $0xa, %r12b
jne 0xa998
incl %ebp
movl %ebp, 0x18(%rbx)
incq %r14
movq %r14, 0x8(%rbx)
cmpq %r15, %r14
jne 0xa97d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/disasm.cc
// Function: Disassembler::checkDW[abi:cxx11](unsigned short, unsigned short)
std::string Disassembler::checkDW(uint16_t cur, uint16_t prev) {
  uint32_t addr = (cur << 16) + prev;
  std::string ret = symbols[addr];
  if (ret.empty()) {
    addr = (prev << 16) + cur;
    ret = symbols[addr];
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
shll $0x10, %ebp
orl %ecx, %ebp
leaq 0x4(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0xa9ae
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x68c2
cmpq $0x0, 0x8(%rbx)
jne 0xf078
roll $0x10, %ebp
leaq 0x4(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0xa9ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xf09c
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/api.cc
// Function: Fingerprints::add(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char)
void Fingerprints::add(const std::vector<uint8_t> &keys, std::string name,
                       uint8_t numDB) {
  auto node = root;
  for (auto key : keys) {
    if (node->map.find(key) == node->map.end()) {
      node->map.insert(std::pair<uint8_t, std::shared_ptr<Fingerprint>>
                       (key, std::make_shared<Fingerprint>()));
    }
    node = node->map[key];
  }
  node->name = name;
  node->numDB = numDB;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x24(%rsp)
movq %rdx, 0x28(%rsp)
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xfa02
movq 0x115d4(%rip), %rcx     # 0x20fc8
cmpb $0x0, (%rcx)
je 0xf9fe
incl 0x8(%rax)
jmp 0xfa02
lock
incl 0x8(%rax)
movq (%rsi), %rbx
movq 0x8(%rsi), %r14
cmpq %r14, %rbx
je 0xfb31
leaq 0x18(%rsp), %r15
xorl %r12d, %r12d
leaq 0xf(%rsp), %r13
movb (%rbx), %cl
movb %cl, 0xf(%rsp)
movq 0x10(%rsp), %rbp
movq 0x10(%rbp), %rsi
leaq 0x8(%rbp), %rax
movq %rax, %rdx
testq %rsi, %rsi
je 0xfa54
movq %rax, %rdx
xorl %edi, %edi
cmpb %cl, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0xfa3d
movq %rax, %rsi
cmpq %rax, %rdx
je 0xfa66
cmpb 0x20(%rdx), %cl
cmovbq %rax, %rdx
movq %rdx, %rsi
cmpq %rax, %rsi
jne 0xfb01
movl $0x68, %edi
callq 0x5220
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x110f2(%rip), %rcx     # 0x20b80
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x18(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x10(%rax)
movq %r12, 0x60(%rax)
movq %rdx, 0x28(%rax)
movq %rdx, 0x30(%rax)
movq %r12, 0x38(%rax)
movq %rax, %rdx
addq $0x58, %rdx
movq %rdx, 0x48(%rax)
movq %r12, 0x50(%rax)
movb $0x0, 0x58(%rax)
movb 0xf(%rsp), %dl
movb %dl, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq %rbp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x12242
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xfb01
callq 0x6752
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x11f92
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
addq $0x8, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x7f60
incq %rbx
cmpq %r14, %rbx
jne 0xfa1f
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x28(%rsp), %rsi
callq 0x5170
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
movb %cl, 0x30(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xfb5f
callq 0x6752
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfb86
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xfb89
callq 0x6752
jmp 0xfb89
jmp 0xfb86
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xfb98
callq 0x6752
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_c_makefile_star2_O1/mrkite[P]regs/src/api.cc
// Function: API::setEnum(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setEnum(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto e = std::static_pointer_cast<symbol::Enum>(s);
  e->type = lookup(h->r32());
  auto num = h->r32();
  for (uint32_t i = 0; i < num; i++) {
    auto value = h->r32();
    e->entries[h->rs()] = value;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq (%rdx), %r15
movq 0x8(%rdx), %rbx
testq %rbx, %rbx
je 0x10745
movq 0x10891(%rip), %rax     # 0x20fc8
cmpb $0x0, (%rax)
je 0x10741
incl 0x8(%rbx)
jmp 0x10745
lock
incl 0x8(%rbx)
movq (%r14), %rdi
movq %rbx, 0x8(%rsp)
callq 0x9904
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x11334
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x30(%r15), %rdi
movups %xmm0, 0x28(%r15)
testq %rdi, %rdi
je 0x10781
callq 0x6752
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x10790
callq 0x6752
movq (%r14), %rdi
callq 0x9904
movl %eax, %ebp
testl %eax, %eax
je 0x107eb
addq $0x38, %r15
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r12
movq (%r14), %rdi
callq 0x9904
movl %eax, %r13d
movq (%r14), %rsi
movq %r12, %rdi
callq 0x99ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x12072
movl %r13d, (%rax)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x107e7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5230
decl %ebp
jne 0x107ac
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x107fa
callq 0x6752
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1080f
jmp 0x1080f
jmp 0x1080f
movq %rax, %r14
cmpq $0x0, 0x8(%rsp)
je 0x10824
movq 0x8(%rsp), %rdi
callq 0x6752
movq %r14, %rdi
callq 0x53e0
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x10812
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x10812