LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/conf.c
// Function: conf_grab_mouse
void
conf_grab_mouse(struct client_ctx *cc)
{
	struct mousebinding	*mb;
	int			 button;

	TAILQ_FOREACH(mb, &Conf.mousebindingq, entry) {
		if (mb->context != MOUSEBIND_CTX_WIN)
			continue;

		switch(mb->button) {
		case 1:
			button = Button1;
			break;
		case 2:
			button = Button2;
			break;
		case 3:
			button = Button3;
			break;
		default:
			warnx("strange button in mousebinding\n");
			continue;
		}
		xu_btn_grab(cc->win, mb->modmask, button);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xaab5(%rip), %rax      # 0x14770
movq 0x40(%rax), %r15
testq %r15, %r15
je 0x9d02
movq %rdi, %rbx
leaq 0x470e(%rip), %r14      # 0xe3dc
cmpl $0x2, 0x20(%r15)
jne 0x9cfa
movl 0x1c(%r15), %edx
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x9cf0
movq 0x38(%rbx), %rdi
movl 0x18(%r15), %esi
callq 0x8921
jmp 0x9cfa
movq %r14, %rdi
xorl %eax, %eax
callq 0x5140
movq (%r15), %r15
testq %r15, %r15
jne 0x9cce
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_keypress
static void
xev_handle_keypress(XEvent *ee)
{
	XKeyEvent		*e = &ee->xkey;
	struct client_ctx	*cc = NULL, fakecc;
	struct keybinding	*kb;
	KeySym			 keysym, skeysym;
	int			 modshift;

	keysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 0);
	skeysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 1);

	/* we don't care about caps lock and numlock here */
	e->state &= ~(LockMask | Mod2Mask);

	TAILQ_FOREACH(kb, &Conf.keybindingq, entry) {
		if (keysym != kb->keysym && skeysym == kb->keysym)
			modshift = ShiftMask;
		else
			modshift = 0;

		if ((kb->modmask | modshift) != e->state)
			continue;

		if ((kb->keycode != 0 && kb->keysym == NoSymbol &&
		    kb->keycode == e->keycode) || kb->keysym ==
		    (modshift == 0 ? keysym : skeysym))
			break;
	}

	if (kb == NULL)
		return;
	if (kb->flags & KBFLAG_NEEDCLIENT) {
		if (((cc = client_find(e->window)) == NULL) &&
		    (cc = client_current()) == NULL)
			return;
	} else {
		cc = &fakecc;
		cc->sc = screen_fromroot(e->window);
	}

	(*kb->callback)(cc, &kb->argument);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0xcb3a(%rip), %r15      # 0x16858
movq (%r15), %rdi
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5270
movq %rax, %r14
movq (%r15), %rdi
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x5270
movl 0x50(%rbx), %ecx
andl $-0x13, %ecx
movl %ecx, 0x50(%rbx)
leaq 0xaa1c(%rip), %rdx      # 0x14770
movq (%rdx), %r15
testq %r15, %r15
je 0x9de7
movl 0x24(%r15), %esi
movslq %esi, %rdx
cmpq %rdx, %r14
setne %dil
cmpq %rdx, %rax
sete %r8b
andb %dil, %r8b
movzbl %r8b, %edi
orl 0x20(%r15), %edi
cmpl %ecx, %edi
jne 0x9da8
movl 0x28(%r15), %edi
testl %edi, %edi
sete %r8b
testl %esi, %esi
setne %sil
orb %r8b, %sil
jne 0x9d9e
cmpl 0x54(%rbx), %edi
je 0x9dad
cmpq %rdx, %r14
je 0x9dad
cmpq %rdx, %rax
je 0x9dad
movq (%r15), %r15
jmp 0x9d57
testb $0x1, 0x2c(%r15)
movq 0x20(%rbx), %rdi
jne 0x9dc8
callq 0x5fc4
leaq 0x8(%rsp), %rdi
movq %rax, 0x30(%rdi)
jmp 0x9ddf
callq 0x61f0
testq %rax, %rax
jne 0x9ddc
callq 0x6da4
testq %rax, %rax
je 0x9de7
movq %rax, %rdi
leaq 0x18(%r15), %rsi
callq *0x10(%r15)
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_keyrelease
static void
xev_handle_keyrelease(XEvent *ee)
{
	XKeyEvent		*e = &ee->xkey;
	struct screen_ctx	*sc;
	struct client_ctx	*cc;
	int			 i, keysym;

	sc = screen_fromroot(e->root);
	cc = client_current();

	keysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 0);
	for (i = 0; i < nitems(modkeys); i++) {
		if (keysym == modkeys[i]) {
			client_cycle_leave(sc, cc);
			break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x28(%rdi), %rdi
callq 0x5fc4
movq %rax, %rbx
callq 0x6da4
movq %rax, %r14
leaq 0xca41(%rip), %rax      # 0x16858
movq (%rax), %rdi
movzbl 0x54(%r15), %esi
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5270
cltq
leaq 0x49bc(%rip), %rcx      # 0xe7f0
cmpq (%r15,%rcx), %rax
je 0x9e4a
addq $0x8, %r15
cmpq $0x30, %r15
jne 0x9e34
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x72cb
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_buttonpress
static void
xev_handle_buttonpress(XEvent *ee)
{
	XButtonEvent		*e = &ee->xbutton;
	struct client_ctx	*cc, fakecc;
	struct screen_ctx	*sc;
	struct mousebinding	*mb;

	sc = screen_fromroot(e->root);
	cc = client_find(e->window);

	/* Ignore caps lock and numlock */
	e->state &= ~(Mod2Mask | LockMask);

	TAILQ_FOREACH(mb, &Conf.mousebindingq, entry) {
		if (e->button == mb->button && e->state == mb->modmask)
			break;
	}

	if (mb == NULL)
		return;
	if (mb->context == MOUSEBIND_CTX_ROOT) {
		if (e->window != sc->rootwin)
			return;
		cc = &fakecc;
		cc->sc = screen_fromroot(e->window);
	} else if (cc == NULL) /* (mb->context == MOUSEBIND_CTX_WIN */
		return;

	(*mb->callback)(cc, e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x5fc4
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x61f0
movl 0x50(%rbx), %ecx
andl $-0x13, %ecx
movl %ecx, 0x50(%rbx)
leaq 0xa8e2(%rip), %rdx      # 0x14770
movq 0x40(%rdx), %r15
testq %r15, %r15
je 0x9ee3
movl 0x54(%rbx), %edx
cmpl 0x1c(%r15), %edx
jne 0x9ea6
cmpl 0x18(%r15), %ecx
je 0x9eb0
movq (%r15), %r15
testq %r15, %r15
jne 0x9e9a
jmp 0x9ee3
cmpl $0x1, 0x20(%r15)
jne 0x9ed4
movq 0x20(%rbx), %rdi
cmpq 0x18(%r14), %rdi
jne 0x9ee3
callq 0x5fc4
movq %rax, %rcx
leaq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x9ed9
testq %rax, %rax
je 0x9ee3
movq %rax, %rdi
movq %rbx, %rsi
callq *0x10(%r15)
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_unmapnotify
static void
xev_handle_unmapnotify(XEvent *ee)
{
	XUnmapEvent		*e = &ee->xunmap;
	XEvent			ev;
	struct client_ctx	*cc;

	/* XXX, we need a recursive locking wrapper around grab server */
	XGrabServer(X_Dpy);
	if ((cc = client_find(e->window)) != NULL) {
		/*
		 * If it's going to die anyway, nuke it.
		 *
		 * Else, if it's a synthetic event delete state, since they
		 * want it to be withdrawn. ICCM recommends you withdraw on
		 * this even if we haven't alredy been told to iconify, to
		 * deal with legacy clients.
		 */
		if (XCheckTypedWindowEvent(X_Dpy, cc->win,
		    DestroyNotify, &ev) || e->send_event != 0) {
			client_delete(cc);
		} else
			client_hide(cc);
	}
	XUngrabServer(X_Dpy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0xc8d9(%rip), %r15      # 0x16858
movq (%r15), %rdi
callq 0x5120
movq 0x28(%rbx), %rdi
callq 0x61f0
testq %rax, %rax
je 0x9fbe
movq %rax, %r14
movq (%r15), %rdi
movq 0x38(%rax), %rsi
movq %rsp, %rcx
movl $0x11, %edx
callq 0x5100
testl %eax, %eax
jne 0x9fb6
cmpl $0x0, 0x10(%rbx)
je 0x9fd3
movq %r14, %rdi
callq 0x6afa
movq (%r15), %rdi
callq 0x5430
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x6a66
jmp 0x9fbe
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_maprequest
static void
xev_handle_maprequest(XEvent *ee)
{
	XMapRequestEvent	*e = &ee->xmaprequest;
	struct client_ctx	*cc = NULL, *old_cc;
	XWindowAttributes	 xattr;

	if ((old_cc = client_current()) != NULL)
		client_ptrsave(old_cc);

	if ((cc = client_find(e->window)) == NULL) {
		XGetWindowAttributes(X_Dpy, e->window, &xattr);
		cc = client_new(e->window, screen_fromroot(xattr.root), 1);
	}

	if ((cc->flags & CLIENT_IGNORE) == 0)
		client_ptrwarp(cc);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x6da4
testq %rax, %rax
je 0x9ffc
movq %rax, %rdi
callq 0x7161
movq 0x28(%rbx), %rdi
callq 0x61f0
testq %rax, %rax
jne 0xa040
leaq 0xc847(%rip), %rax      # 0x16858
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x5720
movq 0x28(%rbx), %rbx
movq 0x20(%r14), %rdi
callq 0x5fc4
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x6209
testb $0x2, 0xa8(%rax)
jne 0xa051
movq %rax, %rdi
callq 0x70e5
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_configurerequest
static void
xev_handle_configurerequest(XEvent *ee)
{
	XConfigureRequestEvent	*e = &ee->xconfigurerequest;
	struct client_ctx	*cc;
	struct screen_ctx	*sc;
	XWindowChanges		 wc;

	if ((cc = client_find(e->window)) != NULL) {
		sc = cc->sc;

		if (e->value_mask & CWWidth)
			cc->geom.w = e->width;
		if (e->value_mask & CWHeight)
			cc->geom.h = e->height;
		if (e->value_mask & CWX)
			cc->geom.x = e->x;
		if (e->value_mask & CWY)
			cc->geom.y = e->y;
		if (e->value_mask & CWBorderWidth)
			wc.border_width = e->border_width;

		if (cc->geom.x == 0 && cc->geom.w >= sc->view.w)
			cc->geom.x -= cc->bwidth;

		if (cc->geom.y == 0 && cc->geom.h >= sc->view.h)
			cc->geom.y -= cc->bwidth;

		wc.x = cc->geom.x;
		wc.y = cc->geom.y;
		wc.width = cc->geom.w;
		wc.height = cc->geom.h;
		wc.border_width = cc->bwidth;

		XConfigureWindow(X_Dpy, cc->win, e->value_mask, &wc);
		xu_configure(cc);
	} else {
		/* let it do what it wants, it'll be ours when we map it. */
		wc.x = e->x;
		wc.y = e->y;
		wc.width = e->width;
		wc.height = e->height;
		wc.border_width = e->border_width;
		wc.stack_mode = Above;
		e->value_mask &= ~CWStackMode;

		XConfigureWindow(X_Dpy, e->window, e->value_mask, &wc);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x61f0
testq %rax, %rax
je 0xa12f
movq %rax, %rbx
movq 0x58(%r14), %rdx
testb $0x4, %dl
je 0xa08b
movl 0x38(%r14), %eax
movl %eax, 0x5c(%rbx)
testb $0x8, %dl
je 0xa097
movl 0x3c(%r14), %eax
movl %eax, 0x60(%rbx)
testb $0x1, %dl
je 0xa0a3
movl 0x30(%r14), %eax
movl %eax, 0x54(%rbx)
testb $0x2, %dl
je 0xa0af
movl 0x34(%r14), %eax
movl %eax, 0x58(%rbx)
testb $0x10, %dl
je 0xa0bc
movl 0x40(%r14), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rbx), %rax
cmpl $0x0, 0x54(%rbx)
jne 0xa0d9
movl 0x5c(%rbx), %ecx
cmpl 0xac(%rax), %ecx
jl 0xa0d9
xorl %ecx, %ecx
subl 0x50(%rbx), %ecx
movl %ecx, 0x54(%rbx)
cmpl $0x0, 0x58(%rbx)
jne 0xa0f2
movl 0x60(%rbx), %ecx
cmpl 0xb0(%rax), %ecx
jl 0xa0f2
xorl %eax, %eax
subl 0x50(%rbx), %eax
movl %eax, 0x58(%rbx)
movl 0x54(%rbx), %eax
movq %rsp, %rcx
movl %eax, (%rcx)
movl 0x58(%rbx), %eax
movl %eax, 0x4(%rcx)
movl 0x5c(%rbx), %eax
movl %eax, 0x8(%rcx)
movl 0x60(%rbx), %eax
movl %eax, 0xc(%rcx)
movl 0x50(%rbx), %eax
movl %eax, 0x10(%rcx)
leaq 0xc73f(%rip), %rax      # 0x16858
movq (%rax), %rdi
movq 0x38(%rbx), %rsi
callq 0x50e0
movq %rbx, %rdi
callq 0x8b8b
jmp 0xa17a
movl 0x30(%r14), %eax
movq %rsp, %rcx
movl %eax, (%rcx)
movl 0x34(%r14), %eax
movl %eax, 0x4(%rcx)
movl 0x38(%r14), %eax
movl %eax, 0x8(%rcx)
movl 0x3c(%r14), %eax
movl %eax, 0xc(%rcx)
movl 0x40(%r14), %eax
movl %eax, 0x10(%rcx)
movl $0x0, 0x20(%rcx)
movq 0x28(%r14), %rsi
movq 0x58(%r14), %rdx
andq $-0x41, %rdx
movq %rdx, 0x58(%r14)
leaq 0xc6e6(%rip), %rax      # 0x16858
movq (%rax), %rdi
callq 0x50e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_propertynotify
static void
xev_handle_propertynotify(XEvent *ee)
{
	XPropertyEvent		*e = &ee->xproperty;
	struct screen_ctx	*sc;
	struct client_ctx	*cc;

	if ((cc = client_find(e->window)) != NULL) {
		switch (e->atom) {
		case XA_WM_NORMAL_HINTS:
			client_getsizehints(cc);
			break;
		case XA_WM_NAME:
			client_setname(cc);
			break;
		case XA_WM_TRANSIENT_FOR:
			client_transient(cc);
			break;
		default:
			/* do nothing */
			break;
		}
	} else {
		TAILQ_FOREACH(sc, &Screenq, entry) 
			if (sc->rootwin == e->window)
				goto test;
		return;
test:
		if (e->atom == ewmh[_NET_DESKTOP_NAMES].atom)
			group_update_names(sc);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x61f0
testq %rax, %rax
je 0xa1b3
movq 0x28(%rbx), %rcx
cmpq $0x27, %rcx
je 0xa1f1
cmpq $0x44, %rcx
je 0xa1e8
cmpq $0x28, %rcx
jne 0xa1e6
movq %rax, %rdi
popq %rbx
jmp 0x66b1
leaq 0xa2c6(%rip), %rdi      # 0x14480
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa1e6
movq 0x18(%rdi), %rax
cmpq 0x20(%rbx), %rax
jne 0xa1ba
movq 0x28(%rbx), %rax
leaq 0xa329(%rip), %rcx      # 0x14500
cmpq 0xa8(%rcx), %rax
jne 0xa1e6
popq %rbx
jmp 0xa427
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x69f0
movq %rax, %rdi
popq %rbx
jmp 0x67e8
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_clientmessage
static void
xev_handle_clientmessage(XEvent *ee)
{
	XClientMessageEvent	*e = &ee->xclient;
	Atom			 xa_wm_change_state;
	struct client_ctx	*cc;

	xa_wm_change_state = XInternAtom(X_Dpy, "WM_CHANGE_STATE", False);

	if ((cc = client_find(e->window)) == NULL)
		return;

	if (e->message_type == xa_wm_change_state && e->format == 32 &&
	    e->data.l[0] == IconicState)
		client_hide(cc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc650(%rip), %rax      # 0x16858
movq (%rax), %rdi
leaq 0x460e(%rip), %rsi      # 0xe820
xorl %edx, %edx
callq 0x56a0
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x61f0
testq %rax, %rax
je 0xa24c
cmpq %r14, 0x28(%rbx)
jne 0xa24c
cmpl $0x20, 0x30(%rbx)
jne 0xa24c
cmpq $0x3, 0x38(%rbx)
jne 0xa24c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a66
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_handle_mappingnotify
static void
xev_handle_mappingnotify(XEvent *ee)
{
	XMappingEvent		*e = &ee->xmapping;
	struct keybinding	*kb;

	TAILQ_FOREACH(kb, &Conf.keybindingq, entry)
		conf_ungrab(&Conf, kb);

	XRefreshKeyboardMapping(e);

	TAILQ_FOREACH(kb, &Conf.keybindingq, entry)
		conf_grab(&Conf, kb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa50a(%rip), %r12      # 0x14770
movq (%r12), %r14
testq %r14, %r14
je 0xa289
leaq 0xa4fa(%rip), %r15      # 0x14770
movq %r15, %rdi
movq %r14, %rsi
callq 0x9c7a
movq (%r14), %r14
testq %r14, %r14
jne 0xa276
movq %rbx, %rdi
callq 0x5110
movq (%r12), %rbx
testq %rbx, %rbx
je 0xa2b4
leaq 0xa4cf(%rip), %r14      # 0x14770
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9c45
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xa2a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/xevents.c
// Function: xev_loop
void
xev_loop(void)
{
	XEvent		 e;

	while (xev_quit == 0) {
		XNextEvent(X_Dpy, &e);
		if (e.type - Randr_ev == RRScreenChangeNotify)
			xev_handle_randr(&e);
		else if (e.type < LASTEvent && xev_handlers[e.type] != NULL)
			(*xev_handlers[e.type])(&e);
	}
}

// Assembly:
cmpl $0x0, 0xc5d5(%rip)      # 0x1689c
je 0xa2ca
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0xc576(%rip), %r15      # 0x16858
leaq 0x8(%rsp), %rbx
leaq 0xc59e(%rip), %r12      # 0x1688c
leaq 0xa18b(%rip), %r13      # 0x14480
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5460
movslq 0x8(%rsp), %rax
cmpl (%r12), %eax
jne 0xa343
movq (%r15), %rdi
movq 0x30(%rsp), %rsi
callq 0x5740
movq (%r13), %r14
testq %r14, %r14
je 0xa35d
movl %eax, %ebp
cmpl %ebp, 0x10(%r14)
jne 0xa339
movq %rbx, %rdi
callq 0x55b0
movq %r14, %rdi
callq 0x60b3
movq (%r14), %r14
testq %r14, %r14
jne 0xa323
jmp 0xa35d
cmpl $0x23, %eax
jg 0xa35d
leaq 0xa291(%rip), %rcx      # 0x145e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0xa35d
movq %rbx, %rdi
callq *%rax
cmpl $0x0, 0xc538(%rip)      # 0x1689c
je 0xa2f5
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_init
void
group_init(struct screen_ctx *sc)
{
	int	 i;

	TAILQ_INIT(&sc->groupq);
	sc->group_hideall = 0;
	/* 
	 * See if any group names have already been set and update the
	 * property with ours if they'll have changed.
	 */
	group_update_names(sc);

	for (i = 0; i < CALMWM_NGROUPS; i++) {
		TAILQ_INIT(&sc->groups[i].clients);
		sc->groups[i].hidden = 0;
		sc->groups[i].shortcut = i + 1;
		TAILQ_INSERT_TAIL(&sc->groupq, &sc->groups[i], entry);
	}

	xu_ewmh_net_wm_desktop_viewport(sc);
	xu_ewmh_net_wm_number_of_desktops(sc);
	xu_ewmh_net_showing_desktop(sc);
	xu_ewmh_net_virtual_roots(sc);

	group_setactive(sc, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2c8(%rdi), %rax
movq $0x0, 0x2c8(%rdi)
movq %rax, 0x2d0(%rdi)
movl $0x0, 0x2d8(%rdi)
callq 0xa427
leaq 0x118(%rbx), %rax
movq $-0x9, %rcx
xorl %edx, %edx
leaq 0x10(%rax), %rsi
movq %rdx, 0x10(%rax)
movq %rsi, 0x18(%rax)
movl $0x0, 0x24(%rax)
leal 0xa(%rcx), %esi
movl %esi, 0x20(%rax)
movq %rdx, (%rax)
movq 0x2d0(%rbx), %rsi
movq %rsi, 0x8(%rax)
movq %rax, (%rsi)
movq %rax, 0x2d0(%rbx)
addq $0x30, %rax
incq %rcx
jne 0xa3b4
movq %rbx, %rdi
callq 0x91b0
movq %rbx, %rdi
callq 0x91f2
movq %rbx, %rdi
callq 0x9232
movq %rbx, %rdi
callq 0x9272
leaq 0x118(%rbx), %rax
movq %rax, 0x2e0(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x928f
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_make_autogroup
void
group_make_autogroup(struct conf *conf, char *val, int no)
{
	struct autogroupwin	*aw;
	char			*p;

	aw = xcalloc(1, sizeof(*aw));

	if ((p = strchr(val, ',')) == NULL) {
		aw->name = NULL;
		aw->class = xstrdup(val);
	} else {
		*(p++) = '\0';
		aw->name = xstrdup(val);
		aw->class = xstrdup(p);
	}
	aw->num = no;

	TAILQ_INSERT_TAIL(&conf->autogroupq, aw, entry);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x61a8
movq %rax, %r14
movq %r15, %rdi
movl $0x2c, %esi
callq 0x5530
testq %rax, %rax
je 0xa67a
movq %rax, %r12
incq %r12
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x61cd
movq %rax, 0x18(%r14)
movq %r12, %rdi
jmp 0xa685
movq $0x0, 0x18(%r14)
movq %r15, %rdi
callq 0x61cd
movq %rax, 0x10(%r14)
movl %ebp, 0x20(%r14)
movq $0x0, (%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_movetogroup
void
group_movetogroup(struct client_ctx *cc, int idx)
{
	struct screen_ctx	*sc = cc->sc;
	struct group_ctx	*gc;

	if (idx < 0 || idx >= CALMWM_NGROUPS)
		err(1, "group_movetogroup: index out of range (%d)", idx);

	gc = &sc->groups[idx];
	if (cc->group == gc)
		return;
	if (gc->hidden) {
		client_hide(cc);
		gc->nhidden++;
	}
	group_add(gc, cc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %edx
cmpl $0x9, %esi
jae 0xa70b
movq %rdi, %rbx
movl %edx, %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x30(%rdi), %rcx
leaq (%rcx,%rax), %r14
addq $0x118, %r14            # imm = 0x118
cmpq %r14, 0xf0(%rdi)
je 0xa703
cmpl $0x0, 0x24(%r14)
je 0xa6f4
movq %rbx, %rdi
callq 0x6a66
incl 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa71e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x414b(%rip), %rsi      # 0xe85d
movl $0x1, %edi
xorl %eax, %eax
callq 0x54c0
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_add
static void
group_add(struct group_ctx *gc, struct client_ctx *cc)
{
	if (cc == NULL || gc == NULL)
		errx(1, "group_add: a ctx is NULL");

	if (cc->group == gc)
		return;

	if (cc->group != NULL)
		TAILQ_REMOVE(&cc->group->clients, cc, group_entry);

	TAILQ_INSERT_TAIL(&gc->clients, cc, group_entry);
	cc->group = gc;

	xu_ewmh_net_wm_desktop(cc);
}

// Assembly:
testq %rdi, %rdi
je 0xa77e
testq %rsi, %rsi
je 0xa77e
movq 0xf0(%rsi), %rax
cmpq %rdi, %rax
je 0xa77d
testq %rax, %rax
je 0xa753
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq 0x18(%rsi), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rsi), %rax
movq %rcx, (%rax)
leaq 0x10(%rsi), %rax
movq $0x0, 0x10(%rsi)
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%rsi)
movq %rsi, (%rcx)
movq %rax, 0x18(%rdi)
movq %rdi, 0xf0(%rsi)
movq %rsi, %rdi
jmp 0x9307
retq
pushq %rax
leaq 0x41ac(%rip), %rsi      # 0xe932
movl $0x1, %edi
xorl %eax, %eax
callq 0x5700
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_sticky_toggle_enter
void
group_sticky_toggle_enter(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	struct group_ctx	*gc;

	gc = sc->group_active;

	if (gc == cc->group) {
		group_remove(cc);
		cc->highlight = CLIENT_HIGHLIGHT_UNGROUP;
	} else {
		group_add(gc, cc);
		cc->highlight = CLIENT_HIGHLIGHT_GROUP;
	}

	client_draw_border(cc);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
movq 0xf0(%rdi), %rax
movq 0x2e0(%rcx), %rdi
cmpq %rax, %rdi
je 0xa7bc
movq %rbx, %rsi
callq 0xa71e
movl $0x1, %eax
jmp 0xa7f8
testq %rbx, %rbx
je 0xa807
testq %rax, %rax
je 0xa807
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rdx, 0x18(%rax)
movq 0x18(%rbx), %rax
movq %rcx, (%rax)
movq $0x0, 0xf0(%rbx)
movq %rbx, %rdi
callq 0x9307
movl $0x2, %eax
movl %eax, 0xb8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6983
leaq 0x413d(%rip), %rsi      # 0xe94b
movl $0x1, %edi
xorl %eax, %eax
callq 0x5700
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_hidetoggle
void
group_hidetoggle(struct screen_ctx *sc, int idx)
{
	struct group_ctx	*gc;

	if (idx < 0 || idx >= CALMWM_NGROUPS)
		err(1, "group_hidetoggle: index out of range (%d)", idx);

	gc = &sc->groups[idx];
	group_fix_hidden_state(gc);

	if (gc->hidden)
		group_show(sc, gc);
	else {
		group_hide(sc, gc);
		/* XXX wtf? */
		if (TAILQ_EMPTY(&gc->clients))
			group_setactive(sc, idx);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %edx
cmpl $0x9, %esi
jae 0xa8d2
movq %rdi, %rbx
movl %edx, %r14d
leaq (%r14,%r14,2), %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r15
addq $0x118, %r15            # imm = 0x118
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xa881
movl 0x24(%r15), %edx
xorl %ecx, %ecx
movl 0xa8(%rax), %esi
andl $0x1, %esi
xorl %edi, %edi
cmpl %esi, %edx
sete %dil
addl %edi, %ecx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa861
testl %ecx, %ecx
jne 0xa88f
xorl %eax, %eax
cmpl $0x0, 0x24(%r15)
sete %al
movl %eax, 0x24(%r15)
cmpl $0x0, 0x24(%r15)
je 0xa8a3
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa8e5
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa08
cmpq $0x0, 0x10(%r15)
je 0xa8bb
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x2e0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x928f
leaq 0x3faf(%rip), %rsi      # 0xe888
movl $0x1, %edi
xorl %eax, %eax
callq 0x54c0
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_show
static void
group_show(struct screen_ctx *sc, struct group_ctx *gc)
{
	struct client_ctx	*cc;
	Window			*winlist;
	u_int			 i;
	int			 lastempty = -1;

	gc->highstack = 0;
	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
		if (cc->stackingorder > gc->highstack)
			gc->highstack = cc->stackingorder;
	}
	winlist = (Window *) xcalloc(sizeof(*winlist), (gc->highstack + 1));

	/*
	 * Invert the stacking order as XRestackWindows() expects them
	 * top-to-bottom.
	 */
	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
		winlist[gc->highstack - cc->stackingorder] = cc->win;
		client_unhide(cc);
	}

	/* Un-sparseify */
	for (i = 0; i <= gc->highstack; i++) {
		if (!winlist[i] && lastempty == -1)
			lastempty = i;
		else if (winlist[i] && lastempty != -1) {
			winlist[lastempty] = winlist[i];
			if (++lastempty == i)
				lastempty = -1;
		}
	}

	XRestackWindows(X_Dpy, winlist, gc->nhidden);
	xfree(winlist);

	gc->hidden = 0;
	group_setactive(sc, gc->shortcut - 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x2c(%rsi)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0xa920
movl 0x2c(%r14), %ecx
movl 0xb4(%rax), %edx
cmpl %ecx, %edx
jle 0xa917
movl %edx, 0x2c(%r14)
movl %edx, %ecx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa907
movslq 0x2c(%r14), %rsi
incq %rsi
movl $0x8, %edi
callq 0x61a8
movq %rax, %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0xa964
movq 0x38(%r12), %rax
movslq 0x2c(%r14), %rcx
movslq 0xb4(%r12), %rdx
subq %rdx, %rcx
movq %rax, (%r15,%rcx,8)
movq %r12, %rdi
callq 0x6abc
movq 0x10(%r12), %r12
jmp 0xa938
movl 0x2c(%r14), %eax
leal 0x1(%rax), %ecx
cmpl $0x1, %ecx
adcl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq (%r15,%rdx,8), %rdi
testq %rdi, %rdi
jne 0xa98f
cmpl $-0x1, %esi
jne 0xa98f
movl %edx, %esi
jmp 0xa9a8
testq %rdi, %rdi
je 0xa9a8
cmpl $-0x1, %esi
je 0xa9a8
movslq %esi, %r8
movq %rdi, (%r15,%r8,8)
incl %esi
cmpq %rsi, %rdx
cmovel %ecx, %esi
incq %rdx
cmpq %rdx, %rax
jne 0xa97d
leaq 0xbea1(%rip), %rax      # 0x16858
movq (%rax), %rdi
movl 0x28(%r14), %edx
movq %r15, %rsi
callq 0x5410
movq %r15, %rdi
callq 0x61c8
movl $0x0, 0x24(%r14)
movslq 0x20(%r14), %rsi
leaq (%rsi,%rsi,2), %rax
decq %rsi
shlq $0x4, %rax
addq %rbx, %rax
addq $0xe8, %rax
movq %rax, 0x2e0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x928f
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_hide
static void
group_hide(struct screen_ctx *sc, struct group_ctx *gc)
{
	struct client_ctx	*cc;

	screen_updatestackingorder(sc);

	gc->nhidden = 0;
	gc->highstack = 0;
	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
		client_hide(cc);
		gc->nhidden++;
		if (cc->stackingorder > gc->highstack)
			gc->highstack = cc->stackingorder;
	}
	gc->hidden = 1;		/* XXX: equivalent to gc->nhidden > 0 */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x5fe5
movq $0x0, 0x28(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0xaa45
movq %r14, %rdi
callq 0x6a66
incl 0x28(%rbx)
movl 0xb4(%r14), %eax
cmpl 0x2c(%rbx), %eax
jle 0xaa3f
movl %eax, 0x2c(%rbx)
movq 0x10(%r14), %r14
jmp 0xaa20
movl $0x1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_only
void
group_only(struct screen_ctx *sc, int idx)
{
	int	 i;

	if (idx < 0 || idx >= CALMWM_NGROUPS)
		err(1, "group_only: index out of range (%d)", idx);

	for (i = 0; i < CALMWM_NGROUPS; i++) {
		if (i == idx)
			group_show(sc, &sc->groups[i]);
		else
			group_hide(sc, &sc->groups[i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %edx
cmpl $0x8, %esi
ja 0xaaa3
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movl %edx, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
cmpq %r12, %r15
jne 0xaa85
callq 0xa8e5
jmp 0xaa8a
callq 0xaa08
incq %r12
addq $0x30, %r14
cmpq $0x9, %r12
jne 0xaa73
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3e08(%rip), %rsi      # 0xe8b2
movl $0x1, %edi
xorl %eax, %eax
callq 0x54c0
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_cycle
void
group_cycle(struct screen_ctx *sc, int flags)
{
	struct group_ctx	*gc, *showgroup = NULL;

	assert(sc->group_active != NULL);

	gc = sc->group_active;
	for (;;) {
		gc = (flags & CWM_RCYCLE) ? TAILQ_PREV(gc, group_ctx_q,
		    entry) : TAILQ_NEXT(gc, entry);
		if (gc == NULL)
			gc = (flags & CWM_RCYCLE) ? TAILQ_LAST(&sc->groupq,
			    group_ctx_q) : TAILQ_FIRST(&sc->groupq);
		if (gc == sc->group_active)
			break;

		if (!TAILQ_EMPTY(&gc->clients) && showgroup == NULL)
			showgroup = gc;
		else if (!gc->hidden)
			group_hide(sc, gc);
	}

	if (showgroup == NULL)
		return;

	group_hide(sc, sc->group_active);

	if (showgroup->hidden)
		group_show(sc, showgroup);
	else
		group_setactive(sc, showgroup->shortcut - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2e0(%rdi), %r15
testq %r15, %r15
je 0xaba0
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2c8(%rdi), %r12
xorl %r14d, %r14d
testb $0x2, %bpl
je 0xaaeb
movq 0x8(%r15), %rax
movq 0x8(%rax), %r15
movq (%r15), %r15
testq %r15, %r15
jne 0xab0a
movq %r12, %rax
testb $0x2, %bpl
je 0xab07
movq 0x2d0(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
movq 0x2e0(%rbx), %rsi
cmpq %rsi, %r15
je 0xab41
testq %r14, %r14
setne %al
cmpq $0x0, 0x10(%r15)
sete %cl
orb %al, %cl
je 0xab3c
cmpl $0x0, 0x24(%r15)
jne 0xaadd
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa08
jmp 0xaadd
movq %r15, %r14
jmp 0xaadd
testq %r14, %r14
je 0xab68
movq %rbx, %rdi
callq 0xaa08
cmpl $0x0, 0x24(%r14)
je 0xab71
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8e5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq 0x20(%r14), %rsi
leaq (%rsi,%rsi,2), %rax
decq %rsi
shlq $0x4, %rax
addq %rbx, %rax
addq $0xe8, %rax
movq %rax, 0x2e0(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x928f
leaq 0x3d2f(%rip), %rdi      # 0xe8d6
leaq 0x3d41(%rip), %rsi      # 0xe8ef
leaq 0x3d42(%rip), %rcx      # 0xe8f7
movl $0x131, %edx            # imm = 0x131
callq 0x5190
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_menu
void
group_menu(XButtonEvent *e)
{
	struct screen_ctx	*sc;
	struct group_ctx	*gc;
	struct menu		*mi;
	struct menu_q		 menuq;
	int			 i;

	sc = screen_fromroot(e->root);
	TAILQ_INIT(&menuq);

	for (i = 0; i < CALMWM_NGROUPS; i++) {
		gc = &sc->groups[i];

		if (TAILQ_EMPTY(&gc->clients))
			continue;

		mi = xcalloc(1, sizeof(*mi));
		if (gc->hidden)
			(void)snprintf(mi->text, sizeof(mi->text), "%d: [%s]",
			    gc->shortcut, sc->group_names[i]);
		else
			(void)snprintf(mi->text, sizeof(mi->text), "%d: %s",
			    gc->shortcut, sc->group_names[i]);
		mi->ctx = gc;
		TAILQ_INSERT_TAIL(&menuq, mi, entry);
	}

	if (TAILQ_EMPTY(&menuq))
		return;

	mi = menu_filter(sc, &menuq, NULL, NULL, 0, NULL, NULL);

	if (mi == NULL || mi->ctx == NULL)
		goto cleanup;

	gc = (struct group_ctx *)mi->ctx;

	(gc->hidden) ? group_show(sc, gc) : group_hide(sc, gc);

cleanup:
	while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
		TAILQ_REMOVE(&menuq, mi, entry);
		xfree(mi);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x28(%rdi), %rdi
callq 0x5fc4
movq %rax, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %r15
addq $0x118, %r15            # imm = 0x118
leaq 0x3cff(%rip), %r12      # 0xe92b
leaq 0x3cef(%rip), %r13      # 0xe922
xorl %ebp, %ebp
cmpq $0x0, 0x10(%r15)
je 0xac98
movl $0x1, %edi
movl $0x98, %esi
callq 0x61a8
movq %rax, %r14
leaq 0x20(%rax), %rdi
cmpl $0x0, 0x24(%r15)
movl 0x20(%r15), %ecx
movq %r13, %rdx
cmoveq %r12, %rdx
movq 0x2e8(%rbx), %rax
movq (%rax,%rbp,8), %r8
movl $0x33, %esi
xorl %eax, %eax
callq 0x50b0
movq %r15, 0x88(%r14)
movq $0x0, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x10(%rsp)
incq %rbp
addq $0x30, %r15
cmpq $0x9, %rbp
jne 0xac35
cmpq $0x0, 0x8(%rsp)
je 0xad25
movq $0x0, (%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x74d7
testq %rax, %rax
je 0xad1b
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0xad1b
cmpl $0x0, 0x24(%rsi)
je 0xacf0
movq %rbx, %rdi
callq 0xa8e5
jmp 0xad1b
movq %rbx, %rdi
callq 0xaa08
jmp 0xad1b
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %r14, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x61c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xacfa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_alltoggle
void
group_alltoggle(struct screen_ctx *sc)
{
	int	 i;

	for (i = 0; i < CALMWM_NGROUPS; i++) {
		if (sc->group_hideall)
			group_show(sc, &sc->groups[i]);
		else
			group_hide(sc, &sc->groups[i]);
	}

	sc->group_hideall = (!sc->group_hideall);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x118, %r14d           # imm = 0x118
cmpl $0x0, 0x2d8(%rbx)
je 0xad58
leaq (%rbx,%r14), %rsi
movq %rbx, %rdi
callq 0xa8e5
jmp 0xad64
leaq (%rbx,%r14), %rsi
movq %rbx, %rdi
callq 0xaa08
addq $0x30, %r14
cmpq $0x2c8, %r14            # imm = 0x2C8
jne 0xad41
xorl %eax, %eax
cmpl $0x0, 0x2d8(%rbx)
sete %al
movl %eax, 0x2d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/group.c
// Function: group_autogroup
void
group_autogroup(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	struct autogroupwin	*aw;
	struct group_ctx	*gc;
	int			 no = -1;
	long			*grpno;

	if (cc->app_class == NULL || cc->app_name == NULL)
		return;

	if (xu_getprop(cc->win, ewmh[_NET_WM_DESKTOP].atom,
	    XA_CARDINAL, 1, (unsigned char **)&grpno) > 0) {
		if (*grpno == 0xffffffff)
			no = 0;
		else if (*grpno > CALMWM_NGROUPS || *grpno < 0)
			no = CALMWM_NGROUPS - 1;
		else
			no = *grpno + 1;
		XFree(grpno);
	} else {
		TAILQ_FOREACH(aw, &Conf.autogroupq, entry) {
			if (strcmp(aw->class, cc->app_class) == 0 &&
			    (aw->name == NULL ||
			    strcmp(aw->name, cc->app_name) == 0)) {
				no = aw->num;
				break;
			}
		}
	}

	/* no group please */
	if (no == 0)
		return;

	TAILQ_FOREACH(gc, &sc->groupq, entry) {
		if (gc->shortcut == no) {
			group_add(gc, cc);
			return;
		}
	}

	if (Conf.flags & CONF_STICKY_GROUPS)
		group_add(sc->group_active, cc);
}

// Assembly:
cmpq $0x0, 0xf8(%rdi)
je 0xaea4
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x100(%rdi)
je 0xae98
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rdi
leaq 0x973b(%rip), %rax      # 0x14500
movq 0xd8(%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x6, %edx
movl $0x1, %ecx
callq 0x8c6f
testl %eax, %eax
jle 0xae2a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0xae07
movl $0x8, %ebp
cmpq $0x9, %rax
ja 0xae07
incl %eax
movl %eax, %ebp
callq 0x5060
testl %ebp, %ebp
je 0xae98
leaq 0x2c8(%r15), %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xae7c
cmpl %ebp, 0x20(%rdi)
jne 0xae1b
jmp 0xae90
leaq 0x993f(%rip), %rax      # 0x14770
movq 0x10(%rax), %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r12, %r12
je 0xae0c
movq 0xf8(%rbx), %r14
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x5620
testl %eax, %eax
jne 0xae71
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0xaea5
movq 0x100(%rbx), %rsi
callq 0x5620
testl %eax, %eax
je 0xaea5
movq (%r12), %r12
testq %r12, %r12
jne 0xae46
jmp 0xae0c
leaq 0x98ed(%rip), %rax      # 0x14770
testb $0x1, 0x50(%rax)
je 0xae98
movq 0x2e0(%r15), %rdi
movq %rbx, %rsi
callq 0xa71e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r12), %ebp
jmp 0xae0c
nop
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/kbfunc.c
// Function: kbfunc_client_search
void
kbfunc_client_search(struct client_ctx *cc, union arg *arg)
{
	struct screen_ctx	*sc = cc->sc;
	struct client_ctx	*old_cc;
	struct menu		*mi;
	struct menu_q		 menuq;

	old_cc = client_current();

	TAILQ_INIT(&menuq);

	TAILQ_FOREACH(cc, &Clientq, entry) {
		mi = xcalloc(1, sizeof(*mi));
		(void)strlcpy(mi->text, cc->name, sizeof(mi->text));
		mi->ctx = cc;
		TAILQ_INSERT_TAIL(&menuq, mi, entry);
	}

	if ((mi = menu_filter(sc, &menuq, "window", NULL, 0,
	    search_match_client, search_print_client)) != NULL) {
		cc = (struct client_ctx *)mi->ctx;
		if (cc->flags & CLIENT_HIDDEN)
			client_unhide(cc);

		if (old_cc)
			client_ptrsave(old_cc);
		client_ptrwarp(cc);
	}

	while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
		TAILQ_REMOVE(&menuq, mi, entry);
		xfree(mi);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x30(%rdi), %r15
callq 0x6da4
movq %rax, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x937f(%rip), %rax      # 0x14490
movq (%rax), %r12
testq %r12, %r12
je 0xb166
movl $0x1, %edi
movl $0x98, %esi
callq 0x61a8
movq %rax, %r14
leaq 0x20(%rax), %rdi
movq 0xd8(%r12), %rsi
movl $0x33, %edx
callq 0xd500
movq %r12, 0x88(%r14)
movq $0x0, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x10(%rsp)
movq (%r12), %r12
jmp 0xb114
leaq -0x2c06(%rip), %rax     # 0x8567
movq %rax, (%rsp)
leaq 0x3841(%rip), %rdx      # 0xe9b9
leaq -0x2e4b(%rip), %r9      # 0x8334
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x74d7
testq %rax, %rax
je 0xb1ea
movq 0x88(%rax), %r15
testb $0x1, 0xa8(%r15)
je 0xb1b2
movq %r15, %rdi
callq 0x6abc
testq %rbx, %rbx
je 0xb1bf
movq %rbx, %rdi
callq 0x7161
movq %r15, %rdi
callq 0x70e5
jmp 0xb1ea
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %r14, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x61c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xb1c9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/kbfunc.c
// Function: kbfunc_menu_search
void
kbfunc_menu_search(struct client_ctx *cc, union arg *arg)
{
	struct screen_ctx	*sc = cc->sc;
	struct cmd		*cmd;
	struct menu		*mi;
	struct menu_q		 menuq;

	TAILQ_INIT(&menuq);

	TAILQ_FOREACH(cmd, &Conf.cmdq, entry) {
		mi = xcalloc(1, sizeof(*mi));
		(void)strlcpy(mi->text, cmd->label, sizeof(mi->text));
		mi->ctx = cmd;
		TAILQ_INSERT_TAIL(&menuq, mi, entry);
	}

	if ((mi = menu_filter(sc, &menuq, "application", NULL, 0,
	    search_match_text, NULL)) != NULL)
		u_spawn(((struct cmd *)mi->ctx)->image);

	while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
		TAILQ_REMOVE(&menuq, mi, entry);
		xfree(mi);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %rbx
leaq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x954c(%rip), %rax      # 0x14770
movq 0x30(%rax), %r15
testq %r15, %r15
je 0xb278
movl $0x1, %edi
movl $0x98, %esi
callq 0x61a8
movq %rax, %r14
leaq 0x20(%rax), %rdi
leaq 0x1014(%r15), %rsi
movl $0x33, %edx
callq 0xd500
movq %r15, 0x88(%r14)
movq $0x0, (%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x18(%rsp)
movq (%r15), %r15
jmp 0xb228
movq $0x0, (%rsp)
leaq 0x3739(%rip), %rdx      # 0xe9c0
leaq -0x2c09(%rip), %r9      # 0x8685
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x74d7
testq %rax, %rax
je 0xb2db
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0x87a4
jmp 0xb2db
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %r14, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x61c8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xb2ba
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/kbfunc.c
// Function: kbfunc_client_label
void
kbfunc_client_label(struct client_ctx *cc, union arg *arg)
{
	struct menu	*mi;
	struct menu_q	 menuq;

	TAILQ_INIT(&menuq);

	/* dummy is set, so this will always return */
	mi = menu_filter(cc->sc, &menuq, "label", cc->label, 1,
	    search_match_text, NULL);

	if (!mi->abort) {
		if (cc->label != NULL)
			xfree(cc->label);
		cc->label = xstrdup(mi->text);
	}
	xfree(mi);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x30(%rdi), %rdi
movq 0xe0(%rbx), %rcx
movq %rax, (%rsp)
leaq 0x2ba6(%rip), %rdx      # 0xe483
leaq -0x325f(%rip), %r9      # 0x8685
movl $0x1, %r8d
callq 0x74d7
movq %rax, %r14
cmpw $0x0, 0x92(%rax)
jne 0xb920
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0xb90d
callq 0x61c8
movq %r14, %rdi
addq $0x20, %rdi
callq 0x61cd
movq %rax, 0xe0(%rbx)
movq %r14, %rdi
callq 0x61c8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_sweep_draw
static void
mousefunc_sweep_draw(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	char			 asize[10]; /* fits "nnnnxnnnn\0" */
	int			 width, width_size, width_name;

	(void)snprintf(asize, sizeof(asize), "%dx%d",
	    (cc->geom.w - cc->hint.basew) / cc->hint.incw,
	    (cc->geom.h - cc->hint.baseh) / cc->hint.inch);
	width_size = font_width(sc, asize, strlen(asize)) + 4;
	width_name = font_width(sc, cc->name, strlen(cc->name)) + 4;
	width = MAX(width_size, width_name);

	XReparentWindow(X_Dpy, sc->menuwin, cc->win, 0, 0);
	XMoveResizeWindow(X_Dpy, sc->menuwin, 0, 0, width, font_height(sc) * 2);
	XMapWindow(X_Dpy, sc->menuwin);
	XClearWindow(X_Dpy, sc->menuwin);
	font_draw(sc, cc->name, strlen(cc->name), sc->menuwin,
	    2, font_ascent(sc) + 1);
	font_draw(sc, asize, strlen(asize), sc->menuwin,
	    width / 2 - width_size / 2, font_height(sc) + font_ascent(sc) + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x5c(%rdi), %eax
movl 0x60(%rdi), %ecx
subl 0x74(%rdi), %eax
cltd
idivl 0x8c(%rdi)
movl %eax, %r8d
subl 0x78(%rdi), %ecx
movl %ecx, %eax
cltd
idivl 0x90(%rdi)
leaq 0x2e25(%rip), %rdx      # 0xea3f
leaq 0x6(%rsp), %r14
movl $0xa, %esi
movq %r14, %rdi
movl %r8d, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x50b0
movq %r14, %rdi
callq 0x5330
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xc1cd
movq %rax, 0x10(%rsp)
leal 0x4(%rax), %r12d
movq 0xd8(%r15), %r14
movq %r14, %rdi
callq 0x5330
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xc1cd
leal 0x4(%rax), %r14d
cmpl %r14d, %r12d
cmovgl %r12d, %r14d
leaq 0xabd8(%rip), %rax      # 0x16858
movq (%rax), %rdi
movq %rax, %r13
movq 0x20(%rbx), %rsi
movq 0x38(%r15), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5800
movq (%r13), %r13
movq 0x20(%rbx), %rbp
movq %rbx, %rdi
callq 0xc129
leal (%rax,%rax), %r9d
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x5450
leaq 0xab93(%rip), %rax      # 0x16858
movq (%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x54d0
leaq 0xab80(%rip), %rax      # 0x16858
movq (%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x50a0
movq 0xd8(%r15), %r15
movq %r15, %rdi
callq 0x5330
movq %rax, %r13
movq 0x20(%rbx), %rbp
movq %rbx, %rdi
callq 0xc114
leal 0x1(%rax), %r9d
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movq %rbp, %rcx
movl $0x2, %r8d
callq 0xc202
leaq 0x6(%rsp), %rdi
callq 0x5330
movq %rax, %r15
movq 0x20(%rbx), %r13
movl %r14d, %ebp
shrl $0x1f, %ebp
addl %r14d, %ebp
sarl %ebp
shrl $0x1f, %r12d
movq 0x10(%rsp), %rax
addl %r12d, %eax
addl $0x4, %eax
sarl %eax
subl %eax, %ebp
movq %rbx, %rdi
callq 0xc129
movl %eax, %r14d
movq %rbx, %rdi
callq 0xc114
leal (%r14,%rax), %r9d
incl %r9d
movq %rbx, %rdi
leaq 0x6(%rsp), %rsi
movl %r15d, %edx
movq %r13, %rcx
movl %ebp, %r8d
callq 0xc202
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_window_move
void
mousefunc_window_move(struct client_ctx *cc, void *arg)
{
	XEvent			 ev;
	Time			 ltime = 0;
	struct screen_ctx	*sc = cc->sc;
	int			 px, py;

	client_raise(cc);

	if (cc->flags & CLIENT_FREEZE)
		return;

	if (xu_ptr_grab(cc->win, MOUSEMASK, Cursor_move) < 0)
		return;

	xu_ptr_getpos(cc->win, &px, &py);

	for (;;) {
		XMaskEvent(X_Dpy, MOUSEMASK|ExposureMask, &ev);

		switch (ev.type) {
		case Expose:
			client_draw_border(cc);
			break;
		case MotionNotify:
			cc->geom.x = ev.xmotion.x_root - px - cc->bwidth;
			cc->geom.y = ev.xmotion.y_root - py - cc->bwidth;

			cc->geom.x += client_snapcalc(cc->geom.x,
			    cc->geom.w, sc->view.w,
			    cc->bwidth, Conf.snapdist);
			cc->geom.y += client_snapcalc(cc->geom.y,
			    cc->geom.h, sc->view.h,
			    cc->bwidth, Conf.snapdist);

			/* don't move more than 60 times / second */
			if ((ev.xmotion.time - ltime) > (1000 / 60)) {
				ltime = ev.xmotion.time;
				client_move(cc);
			}
			break;
		case ButtonRelease:
			if (ltime)
				client_move(cc);
			xu_ptr_ungrab();
			return;
		}
	}
	/* NOTREACHED */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r15
callq 0x70cf
testb $0x10, 0xa8(%rbx)
jne 0xbeb7
movq 0x38(%rbx), %rdi
leaq 0xaaa8(%rip), %rax      # 0x16868
movq (%rax), %rdx
movl $0x4c, %esi
callq 0x88b4
testl %eax, %eax
js 0xbeb7
movq 0x38(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x89e4
xorl %ebp, %ebp
leaq 0xaa69(%rip), %r12      # 0x16858
leaq 0x8(%rsp), %r14
movq (%r12), %rdi
movl $0x804c, %esi           # imm = 0x804C
movq %r14, %rdx
callq 0x55d0
movl 0x8(%rsp), %eax
cmpl $0x6, %eax
je 0xbe27
cmpl $0xc, %eax
je 0xbe1d
cmpl $0x5, %eax
jne 0xbdf4
jmp 0xbea5
movq %rbx, %rdi
callq 0x6983
jmp 0xbdf4
movl 0x50(%rsp), %edi
movl 0x50(%rbx), %ecx
movl 0x5c(%rbx), %esi
movl 0x4(%rsp), %eax
addl %ecx, %eax
subl %eax, %edi
movl %edi, 0x54(%rbx)
movl 0x54(%rsp), %eax
movl (%rsp), %edx
addl %ecx, %edx
subl %edx, %eax
movl %eax, 0x58(%rbx)
movl 0xac(%r15), %edx
leaq 0x8918(%rip), %r13      # 0x14770
movl 0x5c(%r13), %r8d
callq 0x73f3
addl %eax, 0x54(%rbx)
movl 0x50(%rbx), %ecx
movl 0x58(%rbx), %edi
movl 0x60(%rbx), %esi
movl 0xb0(%r15), %edx
movl 0x5c(%r13), %r8d
callq 0x73f3
addl %eax, 0x58(%rbx)
movq 0x40(%rsp), %r13
movq %r13, %rax
subq %rbp, %rax
cmpq $0x11, %rax
jb 0xbdf4
movq %rbx, %rdi
callq 0x695d
movq %r13, %rbp
jmp 0xbdf4
testq %rbp, %rbp
je 0xbeb2
movq %rbx, %rdi
callq 0x695d
callq 0x8910
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_menu_unhide
void
mousefunc_menu_unhide(struct client_ctx *cc, void *arg)
{
	struct screen_ctx	*sc = cc->sc;
	struct client_ctx	*old_cc;
	struct menu		*mi;
	struct menu_q		 menuq;
	char			*wname;

	old_cc = client_current();

	TAILQ_INIT(&menuq);
	TAILQ_FOREACH(cc, &Clientq, entry)
		if (cc->flags & CLIENT_HIDDEN) {
			wname = (cc->label) ? cc->label : cc->name;
			if (wname == NULL)
				continue;

			mi = xcalloc(1, sizeof(*mi));
			(void)strlcpy(mi->text, wname, sizeof(mi->text));
			mi->ctx = cc;
			TAILQ_INSERT_TAIL(&menuq, mi, entry);
		}

	if (TAILQ_EMPTY(&menuq))
		return;

	mi = menu_filter(sc, &menuq, NULL, NULL, 0, NULL, NULL);
	if (mi != NULL) {
		cc = (struct client_ctx *)mi->ctx;
		client_unhide(cc);

		if (old_cc != NULL)
			client_ptrsave(old_cc);
		client_ptrwarp(cc);
	} else {
		while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
			TAILQ_REMOVE(&menuq, mi, entry);
			xfree(mi);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %r14
callq 0x6da4
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x856e(%rip), %rax      # 0x14490
movq (%rax), %r13
testq %r13, %r13
je 0xbf97
testb $0x1, 0xa8(%r13)
je 0xbf91
movq 0xe0(%r13), %r15
testq %r15, %r15
jne 0xbf47
movq 0xd8(%r13), %r15
testq %r15, %r15
je 0xbf91
movl $0x1, %edi
movl $0x98, %esi
callq 0x61a8
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl $0x33, %edx
movq %r15, %rsi
callq 0xd500
movq %r13, 0x88(%r12)
movq $0x0, (%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x18(%rsp)
movq (%r13), %r13
jmp 0xbf25
cmpq $0x0, 0x10(%rsp)
je 0xc017
movq $0x0, (%rsp)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x74d7
testq %rax, %rax
je 0xc00d
movq 0x88(%rax), %r14
movq %r14, %rdi
callq 0x6abc
testq %rbx, %rbx
je 0xbfe2
movq %rbx, %rdi
callq 0x7161
movq %r14, %rdi
callq 0x70e5
jmp 0xc017
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %r15, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x61c8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xbfec
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq