LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: getcolor
unsigned int getcolor(char *color)
{
    xcb_colormap_t map = screen->default_colormap;
    xcb_alloc_color_reply_t *c;
    unsigned int r, g, b, rgb, pixel;

    rgb = xcb_get_colorpixel(color);
    r = rgb >> 16; g = rgb >> 8 & 0xFF; b = rgb & 0xFF;
    c = xcb_alloc_color_reply(dis, xcb_alloc_color(dis, map, r * 257, g * 257,
                                                   b * 257), NULL);
    if (!c)
        errx(EXIT_FAILURE, "error: cannot allocate color '%s'\n", color);

    pixel = c->pixel;
    free(c);

    return pixel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x745d(%rip), %rax      # 0xd7c0
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c80
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movq 0x7402(%rip), %rax      # 0xd7a0
movq %rax, -0x38(%rbp)
movq 0x73f7(%rip), %rdi      # 0xd7a0
movl -0xc(%rbp), %esi
imull $0x101, -0x1c(%rbp), %eax # imm = 0x101
movw %ax, %dx
imull $0x101, -0x20(%rbp), %eax # imm = 0x101
movw %ax, %cx
imull $0x101, -0x24(%rbp), %eax # imm = 0x101
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x34b0
movq -0x38(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x640b
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x3def(%rip), %rsi      # 0xa1f3
movb $0x0, %al
callq 0x31b0
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3050
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_get_atoms
static void xcb_get_atoms(char **names, xcb_atom_t *atoms, unsigned int count)
{
    xcb_intern_atom_cookie_t cookies[count];
    xcb_intern_atom_reply_t  *reply;

    for (unsigned int i = 0; i < count; i++)
        cookies[i] = xcb_intern_atom(dis, 0, strlen(names[i]), names[i]);

    for (unsigned int i = 0; i < count; i++) {
        reply = xcb_intern_atom_reply(dis, cookies[i], NULL);
        if (!reply)
            errx(EXIT_FAILURE, "failed to register %s atom", names[i]);
        DEBUGP("%s : %d\n", names[i], reply->atom);
        atoms[i] = reply->atom; free(reply);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x64d2
movl -0x34(%rbp), %eax
movq %rax, -0x50(%rbp)
movq 0x7319(%rip), %rax      # 0xd7a0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3170
movq -0x58(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl -0x34(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
xorl %esi, %esi
movzwl %ax, %edx
callq 0x3250
movq -0x50(%rbp), %rcx
movl %eax, %edx
movq -0x48(%rbp), %rax
movl %edx, -0x38(%rbp)
movl -0x38(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6471
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6549
movq -0x48(%rbp), %rax
movq 0x72b4(%rip), %rdi      # 0xd7a0
movl -0x3c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3490
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6524
movq -0x8(%rbp), %rax
movl -0x3c(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x3cf9(%rip), %rsi      # 0xa216
movb $0x0, %al
callq 0x31b0
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rdi
callq 0x3050
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x64d9
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_checkotherwm
static int xcb_checkotherwm(void)
{
    xcb_generic_error_t *error;
    unsigned int values[1] = {XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT|
                              XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY|
                              XCB_EVENT_MASK_PROPERTY_CHANGE|
                              XCB_EVENT_MASK_BUTTON_PRESS};

    error = xcb_request_check(dis, xcb_change_window_attributes_checked(dis,
                                    screen->root, XCB_CW_EVENT_MASK, values));
    if (error)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x3aaa(%rip), %eax      # 0xa018
movl %eax, -0x14(%rbp)
movq 0x7228(%rip), %rax      # 0xd7a0
movq %rax, -0x20(%rbp)
movq 0x721d(%rip), %rdi      # 0xd7a0
movq 0x7236(%rip), %rax      # 0xd7c0
movl (%rax), %esi
leaq -0x14(%rbp), %rcx
movl $0x800, %edx            # imm = 0x800
callq 0x3460
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x3430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x65bd
movl $0x1, -0x4(%rbp)
jmp 0x65c4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: grabkeys
void grabkeys(void)
{
    xcb_keycode_t *keycode;
    unsigned int modifiers[] = { 0, XCB_MOD_MASK_LOCK, numlockmask,
                                 numlockmask|XCB_MOD_MASK_LOCK };

    xcb_ungrab_key(dis, XCB_GRAB_ANY, screen->root, XCB_MOD_MASK_ANY);
    for (unsigned int i = 0; i < LENGTH(keys); i++) {
        keycode = xcb_get_keycodes(keys[i].keysym);
        for (unsigned int k = 0; keycode[k] != XCB_NO_SYMBOL; k++)
            for (unsigned int m = 0; m < LENGTH(modifiers); m++)
                xcb_grab_key(dis, 1, screen->root, keys[i].mod | modifiers[m],
                             keycode[k], XCB_GRAB_MODE_ASYNC,
                             XCB_GRAB_MODE_ASYNC);
        free(keycode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x20(%rbp)
movl $0x2, -0x1c(%rbp)
movl 0x71c4(%rip), %eax      # 0xd7b0
movl %eax, -0x18(%rbp)
movl 0x71bb(%rip), %eax      # 0xd7b0
orl $0x2, %eax
movl %eax, -0x14(%rbp)
movq 0x719e(%rip), %rdi      # 0xd7a0
movq 0x71b7(%rip), %rax      # 0xd7c0
movl (%rax), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0x35a0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq $0x21, %rax
jae 0x6704
movl -0x28(%rbp), %eax
movl %eax, %ecx
leaq 0x6d76(%rip), %rax      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
callq 0x3b20
movq %rax, -0x8(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpq $0x0, %rax
je 0x66ed
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpq $0x4, %rax
jae 0x66dd
movq 0x7120(%rip), %rdi      # 0xd7a0
movq 0x7139(%rip), %rax      # 0xd7c0
movl (%rax), %edx
movl -0x28(%rbp), %eax
movl %eax, %ecx
leaq 0x6d1b(%rip), %rax      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl -0x30(%rbp), %ecx
orl -0x20(%rbp,%rcx,4), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %esi
movl %esi, %r8d
movl $0x1, %r9d
movl %r9d, %esi
movzwl %cx, %ecx
movzbl (%rax,%r8), %r8d
movl $0x1, (%rsp)
callq 0x33c0
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6670
jmp 0x66df
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6654
movq -0x8(%rbp), %rdi
callq 0x3050
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6621
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: destroynotify
void destroynotify(xcb_generic_event_t *e)
{
    xcb_destroy_notify_event_t *ev = (xcb_destroy_notify_event_t *)e;
    client *c = wintoclient(ev->window);

    DEBUG("xcb: destroy notify");

    if (c) {
        if (c->isfullscreen)
            destroy_display(c);
        removeclient(c);
    }
   else {
        alien *a;

        if((a = wintoalien(&aliens, ev->window))) {
            DEBUG("unlink selfmapped window");
            rem_node(&a->link);
            free(a);
        }
    }
    desktopinfo();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x88d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6d89
movq -0x18(%rbp), %rax
testb $0x1, 0x1b(%rax)
je 0x6d7e
movq -0x18(%rbp), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rdi
callq 0x8800
jmp 0x6dba
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x6a49(%rip), %rdi      # 0xd7e0
callq 0x8f80
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6db8
movq -0x20(%rbp), %rdi
callq 0x5300
movq -0x20(%rbp), %rdi
callq 0x3050
jmp 0x6dba
callq 0x4f80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: keypress
void keypress(xcb_generic_event_t *e)
{
    xcb_key_press_event_t *ev       = (xcb_key_press_event_t *)e;
    xcb_keysym_t           keysym   = xcb_get_keysym(ev->detail);

    DEBUGP("xcb: keypress: code: %d mod: %d\n", ev->detail, ev->state);
    for (unsigned int i = 0; i < LENGTH(keys); i++)
        if (keysym == keys[i].keysym &&
            CLEANMASK(keys[i].mod) == CLEANMASK(ev->state) &&
            keys[i].func)
                keys[i].func(&keys[i].arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %edi
callq 0x8ff0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpq $0x21, %rax
jae 0x6edc
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
leaq 0x6579(%rip), %rcx      # 0xd3b0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x6ecc
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x655d(%rip), %rax      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl 0x694e(%rip), %ecx      # 0xd7b0
orl $0x2, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movq -0x10(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
movl 0x6938(%rip), %edx      # 0xd7b0
orl $0x2, %edx
xorl $-0x1, %edx
andl %edx, %ecx
cmpl %ecx, %eax
jne 0x6ecc
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x6520(%rip), %rax      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x6ecc
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x6506(%rip), %rax      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
leaq 0x64f1(%rip), %rdi      # 0xd3b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
addq $0x10, %rdi
callq *%rax
jmp 0x6ece
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e1b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x88d0
cmpq $0x0, %rax
je 0x6f1b
jmp 0x6fdb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x9020
cmpq $0x0, -0x20(%rbp)
jne 0x6f43
jmp 0x6fdb
movq -0x20(%rbp), %rax
cmpb $0x0, 0x1b(%rax)
je 0x6f5b
movq -0x20(%rbp), %rdi
callq 0x3050
jmp 0x6fdb
movq -0x20(%rbp), %rdi
callq 0x3050
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x686e(%rip), %rdi      # 0xd7e0
callq 0x8f80
cmpq $0x0, %rax
je 0x6f7f
jmp 0x6fdb
movq 0x6832(%rip), %rax      # 0xd7b8
movq %rax, -0x48(%rbp)
movq 0x6827(%rip), %rdi      # 0xd7b8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x3570
movq -0x48(%rbp), %rdi
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x35e0
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6fd9
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x9100
leaq -0x38(%rbp), %rdi
callq 0x3040
jmp 0x6fdb
jmp 0x6fdb
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x88d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x7565
movq -0x10(%rbp), %rax
cmpl $0x7f, 0x8(%rax)
je 0x7567
jmp 0x75d9
movq 0x6232(%rip), %rax      # 0xd7a0
movq %rax, -0x50(%rbp)
movq 0x6227(%rip), %rdi      # 0xd7a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x3030
movq -0x50(%rbp), %rdi
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
leaq -0x34(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3640
cmpb $0x0, %al
je 0x75d4
movq -0x40(%rbp), %rcx
movq 0x6225(%rip), %rdx      # 0xd7d0
xorl %eax, %eax
cmpq 0x30(%rdx), %rcx
movb %al, -0x51(%rbp)
je 0x75c7
movl -0x34(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
callq 0x4f80
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x88d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x763b
movq -0x18(%rbp), %rdi
callq 0x9290
testb $0x1, %al
jne 0x761a
jmp 0x763b
movq -0x18(%rbp), %rax
testb $0x1, 0x1b(%rax)
je 0x762d
movq -0x18(%rbp), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rdi
callq 0x8800
callq 0x4f80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x9500
movq %rax, -0x10(%rbp)
movq 0x5f5c(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
callq 0x58d0
testb $0x1, %al
jne 0x7897
movq 0x5f48(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
jmp 0x78ab
movq 0x5f32(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x56a0
movl -0x4(%rbp), %edi
callq 0x9650
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x2, -0x1c(%rbp)
movl 0x5ed0(%rip), %eax      # 0xd7b0
movl %eax, -0x18(%rbp)
movl 0x5ec7(%rip), %eax      # 0xd7b0
orl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x78fb
jmp 0x7993
movq 0x5e9e(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x34d0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq $0x5, %rax
jae 0x7993
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpq $0x4, %rax
jae 0x7986
movq 0x5e64(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movl $0x1, %r9d
movl $0x4, %ecx
xorl %r8d, %r8d
movl %r9d, %esi
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x8000, 0x18(%rsp)     # imm = 0x8000
callq 0x3320
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x792c
jmp 0x7988
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x791c
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5c1d(%rip), %rax      # 0xd7d0
movl 0x5c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x7bee
movq 0x5c0b(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7bec
movq -0x10(%rbp), %rdi
callq 0x9660
movq -0x10(%rbp), %rdi
callq 0x5490
movq %rax, -0x10(%rbp)
jmp 0x7bcd
jmp 0x7bee
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq 0x5bd5(%rip), %rax      # 0xd7d0
movl %ecx, 0x5c(%rax)
callq 0x57f0
movq 0x5bc6(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rdi
callq 0x4010
callq 0x4f80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_get_colorpixel
static unsigned int xcb_get_colorpixel(char *hex)
{
    char strgroups[3][3]  = {{hex[1], hex[2], '\0'},
                             {hex[3], hex[4], '\0'},
                             {hex[5], hex[6], '\0'}};
    unsigned int rgb16[3] = {(strtol(strgroups[0], NULL, 16)),
                             (strtol(strgroups[1], NULL, 16)),
                             (strtol(strgroups[2], NULL, 16))};

    return (rgb16[0] << 16) + (rgb16[1] << 8) + rgb16[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x10(%rbp)
movb $0x0, -0xf(%rbp)
movq -0x8(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0xe(%rbp)
movq -0x8(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0xd(%rbp)
movb $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb 0x5(%rax), %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movb 0x6(%rax), %al
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0x11(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x3390
movl %eax, -0x20(%rbp)
leaq -0x11(%rbp), %rdi
addq $0x3, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x3390
movl %eax, -0x1c(%rbp)
leaq -0x11(%rbp), %rdi
addq $0x6, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x3390
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
shll $0x10, %eax
movl -0x1c(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3660
cmpl $0x0, %eax
je 0x7d5c
addq $0x10, %rsp
popq %rbp
retq
cmpq $0x0, 0x5a3c(%rip)      # 0xd7a0
je 0x7d74
movq 0x5a53(%rip), %rax      # 0xd7c0
movl (%rax), %edi
callq 0x32a0
callq 0x32d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3580
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
xorl %edi, %edi
leaq 0x24c9(%rip), %rsi      # 0xa26b
movb $0x0, %al
callq 0x3400
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5a0d(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x7de1
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl 0x5a22(%rip), %eax      # 0xd7f8
je 0x7de1
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jle 0x7de6
jmp 0x7e83
movl 0x5a0c(%rip), %eax      # 0xd7f8
movl %eax, -0xc(%rbp)
movq 0x59da(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5300
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x5570
movq 0x59b7(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x56a0
movl -0xc(%rbp), %edi
callq 0x5570
movq 0x596b(%rip), %rdi      # 0xd7a0
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x5995(%rip), %rax      # 0xd7d8
imull $0xfffffffe, 0x34(%rax), %edx # imm = 0xFFFFFFFE
movq -0x18(%rbp), %r8
addq $0x30, %r8
xorl %ecx, %ecx
callq 0x5410
movq 0x5958(%rip), %rdi      # 0xd7b8
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x3650
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x79a0
callq 0x4f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5911(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x5902(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x7eeb
movq 0x58f4(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x7eed
jmp 0x7f5c
jmp 0x7eef
movq -0x8(%rbp), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x7f0f
movq 0x58cb(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f1c
movq -0x8(%rbp), %rdi
callq 0x5490
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1d(%rax)
jne 0x7f28
jmp 0x7f3d
movq -0x8(%rbp), %rax
movq 0x589d(%rip), %rcx      # 0xd7d0
cmpq 0x30(%rcx), %rax
jne 0x7f3b
jmp 0x7f3d
jmp 0x7eef
movq 0x588c(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rcx
movq 0x5881(%rip), %rax      # 0xd7d0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x4010
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5851(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x5842(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x7fab
movq 0x5834(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x7fad
jmp 0x8011
jmp 0x7faf
movq -0x8(%rbp), %rdi
callq 0x5790
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x7fd1
movq 0x5807(%rip), %rax      # 0xd7d0
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1d(%rax)
jne 0x7fdd
jmp 0x7ff2
movq -0x8(%rbp), %rax
movq 0x57e8(%rip), %rcx      # 0xd7d0
cmpq 0x30(%rcx), %rax
jne 0x7ff0
jmp 0x7ff2
jmp 0x7faf
movq 0x57d7(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rcx
movq 0x57cc(%rip), %rax      # 0xd7d0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x4010
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x57a1(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x804c
movq 0x5793(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x804e
jmp 0x8095
movq 0x577b(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5490
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5300
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x80a0
callq 0x57f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: insert_node_after
static void insert_node_after(list *l, node *c, node *i)
{
    node *n;
    if (!c || !(n = c->next))
        add_tail(l, i);
    else {
        c->next = i;
        i->prev = c;
        i->next = n;
        n->prev = i;
    }
    i->parent = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x80cd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x80dc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56a0
jmp 0x810a
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x56a1(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x814c
movq 0x5693(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rdi
callq 0x5790
cmpq $0x0, %rax
jne 0x814e
jmp 0x8195
movq 0x567b(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5790
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5300
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x81a0
callq 0x57f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: insert_node_before
static void insert_node_before(list *l, node *c, node *i)
{
    node *p;
    if (!c || !(p = c->prev))
        add_head(l, i);
    else {
        p->next = i;
        i->prev = p;
        i->next = c;
        c->prev = i;
    }
    i->parent = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x81cc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x81db
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54f0
jmp 0x8209
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x55a1(%rip), %rax      # 0xd7d0
cmpq $0x0, 0x30(%rax)
je 0x824c
movq 0x5593(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x8251
jmp 0x82d8
movq 0x5578(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq 0x556d(%rip), %rcx      # 0xd7d0
cmpq 0x18(%rcx), %rax
jne 0x829c
movq 0x5560(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x5490
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5300
movq 0x5543(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
callq 0x54f0
jmp 0x82c8
movq 0x552d(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
movq 0x5515(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x54f0
movq 0x5501(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x4010
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8345
movq -0x8(%rbp), %rax
testb $0x1, 0x1b(%rax)
je 0x834a
jmp 0x8414
movq -0x8(%rbp), %rdi
callq 0x57c0
movl %eax, -0x10(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x543c(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movl -0x10(%rbp), %edx
callq 0x3c90
testb $0x1, -0x9(%rbp)
je 0x8403
movq 0x541c(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x543e(%rip), %rax      # 0xd7d0
movl 0x64(%rax), %edx
movq 0x543c(%rip), %rax      # 0xd7d8
movl 0x3c(%rax), %ecx
movq 0x542a(%rip), %rax      # 0xd7d0
addl 0x64(%rax), %ecx
addl $0x0, %ecx
movq 0x5425(%rip), %rax      # 0xd7d8
movl 0x34(%rax), %r8d
movl -0x10(%rbp), %eax
movq 0x540f(%rip), %r9       # 0xd7d0
addl 0x64(%r9), %eax
shll %eax
subl %eax, %r8d
movq 0x5407(%rip), %rax      # 0xd7d8
movl 0x38(%rax), %r9d
movl -0x10(%rbp), %eax
movq 0x53f1(%rip), %r10      # 0xd7d0
addl 0x64(%r10), %eax
shll %eax
subl %eax, %r9d
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
callq 0x3cd0
movq -0x8(%rbp), %rax
movb $0x1, 0x1c(%rax)
jmp 0x840b
movq -0x8(%rbp), %rax
movb $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rdi
callq 0x4010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x4fdf(%rip), %eax      # 0xd7f8
movl %eax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8828
jmp 0x88c4
movq -0x8(%rbp), %rdi
callq 0x5300
movq -0x8(%rbp), %rax
movq 0x4f94(%rip), %rcx      # 0xd7d0
cmpq 0x38(%rcx), %rax
jne 0x8860
movq 0x4f87(%rip), %rax      # 0xd7d0
movq 0x30(%rax), %rdi
callq 0x5790
movq %rax, %rcx
movq 0x4f74(%rip), %rax      # 0xd7d0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x4f65(%rip), %rcx      # 0xd7d0
cmpq 0x30(%rcx), %rax
je 0x8887
movq 0x4f58(%rip), %rax      # 0xd7d0
movq 0x18(%rax), %rdi
callq 0x5490
cmpq $0x0, %rax
jne 0x8897
movq 0x4f42(%rip), %rax      # 0xd7d0
movq 0x38(%rax), %rdi
callq 0x4010
movq -0x8(%rbp), %rdi
callq 0x3050
movq $0x0, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x88bc
callq 0x57f0
jmp 0x88c4
movl -0x10(%rbp), %edi
callq 0x5570
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
leaq 0x4f26(%rip), %rdi      # 0xd808
callq 0x54c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x899b
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x54c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8987
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x54c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8976
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x54c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8965
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x8954
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x89a3
jmp 0x8956
movq -0x30(%rbp), %rdi
callq 0x5490
movq %rax, -0x30(%rbp)
jmp 0x8937
jmp 0x8967
movq -0x28(%rbp), %rdi
callq 0x5490
movq %rax, -0x28(%rbp)
jmp 0x891f
jmp 0x8978
movq -0x20(%rbp), %rdi
callq 0x5490
movq %rax, -0x20(%rbp)
jmp 0x8907
jmp 0x8989
movq -0x18(%rbp), %rdi
callq 0x5490
movq %rax, -0x18(%rbp)
jmp 0x88eb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x4a15(%rip), %rax      # 0xd7d8
cvtsi2sdl 0x34(%rax), %xmm0
movq 0x4a01(%rip), %rax      # 0xd7d0
movss 0x58(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x1228(%rip), %xmm2     # 0xa008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x32, -0xc(%rbp)
jl 0x8e13
movq 0x49d0(%rip), %rax      # 0xd7d8
movl 0x34(%rax), %eax
subl -0xc(%rbp), %eax
cmpl $0x32, %eax
jge 0x8e15
jmp 0x8e33
movq -0x8(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
movq 0x49ac(%rip), %rax      # 0xd7d0
addss 0x58(%rax), %xmm0
movss %xmm0, 0x58(%rax)
callq 0x57f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: get_geometry
static inline xcb_get_geometry_reply_t *get_geometry(xcb_window_t win)
{
    xcb_get_geometry_reply_t *r;
    r = xcb_get_geometry_reply(dis, xcb_get_geometry(dis, win), NULL);
    if (!r)
        errx(EXIT_FAILURE, "failed to get geometry for window %i", win);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x494e(%rip), %rax      # 0xd7a0
movq %rax, -0x20(%rbp)
movq 0x4943(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
callq 0x33b0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e99
movl -0x4(%rbp), %edx
movl $0x1, %edi
leaq 0x13f0(%rip), %rsi      # 0xa282
movb $0x0, %al
callq 0x31b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: float_client
void float_client(client *c)
{
    if (!c)
        return;

    c->isfloating = true;

    if (c->dim[0] && c->dim[1]) {
        if (c->dim[0] < MINWSZ)
            c->dim[0] = MINWSZ;
        if (c->dim[1] < MINWSZ)
            c->dim[1] = MINWSZ;

        xcb_resize(dis, c->win, c->dim[0], c->dim[1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8ec5
jmp 0x8f2c
movq -0x8(%rbp), %rax
movb $0x1, 0x1a(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x8f2c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x8f2c
movq -0x8(%rbp), %rax
cmpl $0x32, 0x28(%rax)
jae 0x8ef6
movq -0x8(%rbp), %rax
movl $0x32, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x32, 0x2c(%rax)
jae 0x8f0b
movq -0x8(%rbp), %rax
movl $0x32, 0x2c(%rax)
movq 0x488e(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
callq 0x8f40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: wintoalien
static alien *wintoalien(list *l, xcb_window_t win)
{
    alien *t;
    if (!l || !win)
        return NULL;

    for (t=(alien *)get_head(l); t; t=(alien *)get_next((node *)t)) {
        if (t->win == win)
            break;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8f9c
cmpl $0x0, -0x14(%rbp)
jne 0x8fa6
movq $0x0, -0x8(%rbp)
jmp 0x8fe1
movq -0x10(%rbp), %rdi
callq 0x54c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8fd9
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x8fc8
jmp 0x8fd9
jmp 0x8fca
movq -0x20(%rbp), %rdi
callq 0x5490
movq %rax, -0x20(%rbp)
jmp 0x8fb3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: xcb_get_attributes
static void xcb_get_attributes(xcb_window_t *windows,
                               xcb_get_window_attributes_reply_t **reply,
                               unsigned int count)
{
    xcb_get_window_attributes_cookie_t cookies[count];

    for (unsigned int i = 0; i < count; i++)
        cookies[i] = xcb_get_window_attributes(dis, windows[i]);
    for (unsigned int i = 0; i < count; i++)
        reply[i] = xcb_get_window_attributes_reply(dis, cookies[i], NULL);
        /* TODO: Handle error */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x90a4
movl -0x2c(%rbp), %eax
movq %rax, -0x48(%rbp)
movq 0x4729(%rip), %rdi      # 0xd7a0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x33e0
movq -0x48(%rbp), %rcx
movl %eax, %edx
movq -0x40(%rbp), %rax
movl %edx, -0x30(%rbp)
movl -0x30(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9061
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x90e6
movq -0x40(%rbp), %rax
movq 0x46e2(%rip), %rdi      # 0xd7a0
movl -0x34(%rbp), %ecx
movl (%rax,%rcx,4), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3230
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x90ab
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3300
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x91d9
movl 0xeeb(%rip), %eax       # 0xa01c
movl %eax, -0x14(%rbp)
movq 0x4665(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
leaq -0x14(%rbp), %rcx
movl $0x800, %edx            # imm = 0x800
callq 0x30f0
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rsi
leaq 0x4672(%rip), %rdi      # 0xd7e0
callq 0x56a0
movq 0x4626(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
callq 0x5890
movq 0x4617(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
callq 0x34c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x8e40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movswl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movswl 0xe(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rdi
callq 0x3050
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: find_client
static client *find_client(xcb_window_t w)
{
    client *c;
    for (c = (client *)get_head(&current_display->clients);
            c && c->win != w; c = (client *)get_next(&c->link)) ;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x45ce(%rip), %rdi      # 0xd7d0
addq $0x18, %rdi
callq 0x54c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x922b
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9234
jmp 0x9245
jmp 0x9236
movq -0x10(%rbp), %rdi
callq 0x5490
movq %rax, -0x10(%rbp)
jmp 0x920f
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop