LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x6074
testq %rax, %rax
je 0x9c0e
movq %rax, %rbx
movq 0x58(%r14), %rdx
testb $0x4, %dl
je 0x9b7a
movl 0x38(%r14), %eax
movl %eax, 0x5c(%rbx)
testb $0x8, %dl
je 0x9b86
movl 0x3c(%r14), %eax
movl %eax, 0x60(%rbx)
testb $0x1, %dl
je 0x9b92
movl 0x30(%r14), %eax
movl %eax, 0x54(%rbx)
testb $0x2, %dl
je 0x9b9e
movl 0x34(%r14), %eax
movl %eax, 0x58(%rbx)
movq 0x30(%rbx), %rcx
movl 0x54(%rbx), %eax
testl %eax, %eax
jne 0x9bbe
movl 0x5c(%rbx), %esi
xorl %eax, %eax
cmpl 0xac(%rcx), %esi
jl 0x9bbe
xorl %eax, %eax
subl 0x50(%rbx), %eax
movl %eax, 0x54(%rbx)
movl 0x58(%rbx), %edi
movl 0x60(%rbx), %esi
testl %edi, %edi
jne 0x9bda
xorl %edi, %edi
cmpl 0xb0(%rcx), %esi
jl 0x9bda
xorl %edi, %edi
subl 0x50(%rbx), %edi
movl %edi, 0x58(%rbx)
movq %rsp, %rcx
movl %eax, (%rcx)
movl %edi, 0x4(%rcx)
movl 0x5c(%rbx), %eax
movl %eax, 0x8(%rcx)
movl %esi, 0xc(%rcx)
movl 0x50(%rbx), %eax
movl %eax, 0x10(%rcx)
leaq 0xcc50(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq 0x38(%rbx), %rsi
callq 0x50e0
movq %rbx, %rdi
callq 0x8763
jmp 0x9c43
movups 0x30(%r14), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movl 0x40(%r14), %eax
movl %eax, 0x10(%rcx)
andl $0x0, 0x20(%rcx)
movq 0x28(%r14), %rsi
movq 0x58(%r14), %rdx
andq $-0x41, %rdx
movq %rdx, 0x58(%r14)
leaq 0xcc0d(%rip), %rax      # 0x16848
movq (%rax), %rdi
callq 0x50e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6074
testq %rax, %rax
je 0x9c7c
movq 0x28(%rbx), %rcx
cmpq $0x27, %rcx
je 0x9cba
cmpq $0x44, %rcx
je 0x9cb1
cmpq $0x28, %rcx
jne 0x9caf
movq %rax, %rdi
popq %rbx
jmp 0x650f
leaq 0xa7ed(%rip), %rdi      # 0x14470
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9caf
movq 0x18(%rdi), %rax
cmpq 0x20(%rbx), %rax
jne 0x9c83
movq 0x28(%rbx), %rax
leaq 0xa850(%rip), %rcx      # 0x144f0
cmpq 0xa8(%rcx), %rax
jne 0x9caf
popq %rbx
jmp 0x9eb5
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x6806
movq %rax, %rdi
popq %rbx
jmp 0x660e
// File: /workspace/github_c_makefile_star2_O2/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 0xcb77(%rip), %rax      # 0x16848
movq (%rax), %rdi
leaq 0x4b35(%rip), %rsi      # 0xe810
xorl %edx, %edx
callq 0x5690
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x6074
testq %rax, %rax
je 0x9d15
cmpq %r14, 0x28(%rbx)
jne 0x9d15
cmpl $0x20, 0x30(%rbx)
jne 0x9d15
cmpq $0x3, 0x38(%rbx)
jne 0x9d15
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x686a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
leaq 0xaa34(%rip), %r14      # 0x14760
movq %r14, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x9d44
movq %r14, %rdi
movq %r15, %rsi
callq 0x9783
jmp 0x9d2f
movq %rbx, %rdi
callq 0x5110
leaq 0xaa0d(%rip), %rbx      # 0x14760
movq %rbx, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x9d6b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9754
jmp 0x9d56
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0xcabf(%rip), %r15      # 0x16848
leaq 0x8(%rsp), %rbx
leaq 0xcae7(%rip), %r12      # 0x1687c
leaq 0xa6d4(%rip), %r13      # 0x14470
cmpl $0x0, 0xcae9(%rip)      # 0x1688c
jne 0x9e09
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5450
movslq 0x8(%rsp), %rax
cmpl (%r12), %eax
jne 0x9ded
movq (%r15), %rdi
movq 0x30(%rsp), %rsi
callq 0x5730
movl %eax, %ebp
movq %r13, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x9d9c
cmpl %ebp, 0x10(%r14)
jne 0x9dcd
movq %rbx, %rdi
callq 0x55a0
movq %r14, %rdi
callq 0x5f47
jmp 0x9dcd
cmpl $0x23, %eax
jg 0x9d9c
leaq 0xa7d7(%rip), %rcx      # 0x145d0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x9d9c
movq %rbx, %rdi
callq *%rax
jmp 0x9d9c
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x2c8(%rdi)
movq %rax, 0x2d0(%rdi)
andl $0x0, 0x2d8(%rdi)
callq 0x9eb5
leaq 0x118(%rbx), %rax
pushq $-0x9
popq %rcx
testq %rcx, %rcx
je 0x9e8a
leaq 0x10(%rax), %rdx
andq $0x0, 0x10(%rax)
movq %rdx, 0x18(%rax)
andl $0x0, 0x24(%rax)
leal 0xa(%rcx), %edx
movl %edx, 0x20(%rax)
andq $0x0, (%rax)
movq 0x2d0(%rbx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rdx)
movq %rax, 0x2d0(%rbx)
incq %rcx
addq $0x30, %rax
jmp 0x9e4c
movq %rbx, %rdi
callq 0x8d1a
movq %rbx, %rdi
callq 0x8d58
movq %rbx, %rdi
callq 0x8d92
movq %rbx, %rdi
callq 0x8dc9
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0xa077
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x6032
movq %rax, %r14
pushq $0x2c
popq %rsi
movq %r15, %rdi
callq 0x5520
testq %rax, %rax
je 0xa0d8
movq %rax, %r12
incq %r12
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x6055
movq %rax, 0x18(%r14)
movq %r12, %rdi
jmp 0xa0e0
andq $0x0, 0x18(%r14)
movq %r15, %rdi
callq 0x6055
movq %rax, 0x10(%r14)
movl %ebp, 0x20(%r14)
andq $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_O2/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 0xa15f
movq %rdi, %rbx
movl %edx, %eax
imulq $0x30, %rax, %rax
movq 0x30(%rdi), %rcx
leaq (%rcx,%rax), %r14
addq $0x118, %r14            # imm = 0x118
cmpq %r14, 0xf0(%rdi)
je 0xa157
cmpl $0x0, 0x24(%r14)
je 0xa148
movq %rbx, %rdi
callq 0x686a
incl 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa170
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x46e7(%rip), %rsi      # 0xe84d
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O2/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 0xa1c9
testq %rsi, %rsi
je 0xa1c9
movq 0xf0(%rsi), %rax
cmpq %rdi, %rax
je 0xa1c8
testq %rax, %rax
je 0xa1a1
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rdx, 0x18(%rax)
movq %rcx, (%rdx)
andq $0x0, 0x10(%rsi)
leaq 0x10(%rsi), %rax
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%rsi)
movq %rsi, (%rcx)
movq %rax, 0x18(%rdi)
movq %rdi, 0xf0(%rsi)
movq %rsi, %rdi
jmp 0x8e54
retq
pushq %rax
leaq 0x4751(%rip), %rsi      # 0xe922
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O2/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 0xa202
movq %rbx, %rsi
callq 0xa170
pushq $0x1
jmp 0xa22f
testq %rdi, %rdi
je 0xa23f
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rdx, 0x18(%rax)
movq %rcx, (%rdx)
andq $0x0, 0xf0(%rbx)
movq %rbx, %rdi
callq 0x8e54
pushq $0x2
popq %rax
movl %eax, 0xb8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x67a1
leaq 0x46f5(%rip), %rsi      # 0xe93b
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O2/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 0xa2f4
movq %rdi, %rbx
movl %edx, %r14d
imulq $0x30, %r14, %rax
leaq (%rdi,%rax), %r15
addq $0x118, %r15            # imm = 0x118
xorl %eax, %eax
movq %r15, %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0xa2a6
movl 0xa8(%rcx), %edx
andl $0x1, %edx
xorl %esi, %esi
cmpl %edx, 0x24(%r15)
sete %sil
addl %esi, %eax
jmp 0xa286
movl 0x24(%r15), %ecx
testl %eax, %eax
jne 0xa2bb
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movl %eax, 0x24(%r15)
movl %eax, %ecx
testl %ecx, %ecx
je 0xa2cc
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa305
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa3fa
cmpq $0x0, 0x10(%r15)
je 0xa2e4
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa077
leaq 0x457d(%rip), %rsi      # 0xe878
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x2c(%rsi)
movq %rdi, %rbx
leaq 0x10(%rsi), %r12
xorl %eax, %eax
movq %r12, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa33e
movl 0xb4(%rcx), %edx
cmpl %eax, %edx
jle 0xa338
movl %edx, 0x2c(%r14)
movl %edx, %eax
addq $0x10, %rcx
jmp 0xa320
incl %eax
movslq %eax, %rsi
pushq $0x8
popq %rdi
callq 0x6032
movq %rax, %r15
movq (%r12), %r12
testq %r12, %r12
je 0xa37d
movq 0x38(%r12), %rax
movslq 0x2c(%r14), %rcx
movslq 0xb4(%r12), %rdx
subq %rdx, %rcx
movq %rax, (%r15,%rcx,8)
movq %r12, %rdi
callq 0x68af
addq $0x10, %r12
jmp 0xa34e
movl 0x2c(%r14), %eax
incl %eax
pushq $-0x1
popq %rcx
xorl %edx, %edx
movl %ecx, %esi
cmpl %edx, %eax
je 0xa3bd
movq (%r15,%rdx,8), %rdi
testq %rdi, %rdi
jne 0xa3a0
cmpl $-0x1, %esi
jne 0xa3a0
movl %edx, %esi
jmp 0xa3b8
testq %rdi, %rdi
je 0xa3b8
cmpl $-0x1, %esi
je 0xa3b8
movslq %esi, %r8
movq %rdi, (%r15,%r8,8)
incl %esi
cmpl %esi, %edx
cmovel %ecx, %esi
incq %rdx
jmp 0xa38a
leaq 0xc484(%rip), %rax      # 0x16848
movq (%rax), %rdi
movl 0x28(%r14), %edx
movq %r15, %rsi
callq 0x5400
movq %r15, %rdi
callq 0x6050
andl $0x0, 0x24(%r14)
movslq 0x20(%r14), %rsi
decq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa077
// File: /workspace/github_c_makefile_star2_O2/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 0x5e7d
andl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rbx, %r14
movl %eax, 0x2c(%rbx)
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xa434
movq %r14, %rdi
callq 0x686a
incl 0x28(%rbx)
movl 0xb4(%r14), %eax
cmpl 0x2c(%rbx), %eax
jle 0xa412
jmp 0xa40f
movl $0x1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movl %esi, %edx
cmpl $0x8, %esi
ja 0xa4a5
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movl %edx, %r12d
imulq $0x30, %r12, %rax
leaq (%rdi,%rax), %r15
addq $0x118, %r15            # imm = 0x118
xorl %r13d, %r13d
cmpq $0x9, %r13
je 0xa49b
movq %rbx, %rdi
cmpq %r13, %r12
jne 0xa48a
movq %r15, %rsi
callq 0xa305
jmp 0xa492
movq %r14, %rsi
callq 0xa3fa
incq %r13
addq $0x30, %r14
jmp 0xa472
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x43f6(%rip), %rsi      # 0xe8a2
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O2/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 0xa58c
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2c8(%rdi), %r12
xorl %r14d, %r14d
testb $0x2, %bpl
jne 0xa4f0
movq (%r15), %r15
movq %r12, %rax
testq %r15, %r15
jne 0xa50e
jmp 0xa50b
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
testq %r15, %r15
jne 0xa50e
movq 0x2d0(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
movq 0x2e0(%rbx), %rsi
cmpq %rsi, %r15
je 0xa545
testq %r14, %r14
setne %al
cmpq $0x0, 0x10(%r15)
sete %cl
orb %al, %cl
je 0xa540
cmpl $0x0, 0x24(%r15)
jne 0xa4dd
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa3fa
jmp 0xa4dd
movq %r15, %r14
jmp 0xa4dd
testq %r14, %r14
je 0xa56c
movq %rbx, %rdi
callq 0xa3fa
cmpl $0x0, 0x24(%r14)
je 0xa575
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa305
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq 0x20(%r14), %rsi
decq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa077
leaq 0x4333(%rip), %rdi      # 0xe8c6
leaq 0x4345(%rip), %rsi      # 0xe8df
leaq 0x4346(%rip), %rcx      # 0xe8e7
movl $0x131, %edx            # imm = 0x131
callq 0x5190
// File: /workspace/github_c_makefile_star2_O2/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 0x5e5c
movq %rax, %rbx
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %r13
addq $0x118, %r13            # imm = 0x118
leaq 0x4304(%rip), %r14      # 0xe912
pushq $0x33
popq %r15
xorl %ebp, %ebp
cmpq $0x9, %rbp
je 0xa689
cmpq $0x0, 0x10(%r13)
je 0xa680
movl $0x98, %esi
pushq $0x1
popq %rdi
callq 0x6032
movq %rax, %r12
leaq 0x20(%rax), %rdi
cmpl $0x0, 0x24(%r13)
movl 0x20(%r13), %ecx
movq 0x2e8(%rbx), %rax
movq (%rax,%rbp,8), %r8
movq %r14, %rdx
leaq 0x42c8(%rip), %rax      # 0xe91b
cmoveq %rax, %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x50b0
movq %r13, 0x88(%r12)
andq $0x0, (%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x10(%rsp)
incq %rbp
addq $0x30, %r13
jmp 0xa614
cmpq $0x0, 0x8(%rsp)
je 0xa702
andq $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 0x7294
testq %rax, %rax
je 0xa6f8
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0xa6f8
cmpl $0x0, 0x24(%rsi)
je 0xa6d1
movq %rbx, %rdi
callq 0xa305
jmp 0xa6f8
movq %rbx, %rdi
callq 0xa3fa
jmp 0xa6f8
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x6050
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xa6db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x2d8(%rbx), %eax
cmpq $0x2c8, %r14            # imm = 0x2C8
je 0xa74a
leaq (%rbx,%r14), %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0xa73f
callq 0xa305
jmp 0xa744
callq 0xa3fa
addq $0x30, %r14
jmp 0xa71e
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0x2d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa85d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x100(%rdi)
je 0xa853
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rdi
leaq 0x9d5c(%rip), %rax      # 0x144f0
movq 0xd8(%rax), %rsi
pushq $0x6
popq %rdx
pushq $0x1
popq %rcx
movq %rsp, %r8
callq 0x8825
testl %eax, %eax
jle 0xa7cb
movq (%rsp), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0xa818
cmpq $0x9, %rax
jbe 0xa814
pushq $0x8
popq %rbp
jmp 0xa818
leaq 0x9f8e(%rip), %r15      # 0x14760
addq $0x10, %r15
pushq $-0x1
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0xa821
movq 0x10(%r15), %rdi
movq 0xf8(%rbx), %rsi
callq 0x5610
testl %eax, %eax
jne 0xa7d9
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xa80e
movq 0x100(%rbx), %rsi
callq 0x5610
testl %eax, %eax
jne 0xa7d9
movl 0x20(%r15), %ebp
jmp 0xa81d
incl %eax
movl %eax, %ebp
callq 0x5060
testl %ebp, %ebp
je 0xa853
leaq 0x2c8(%r14), %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa837
cmpl %ebp, 0x20(%rdi)
jne 0xa828
jmp 0xa84b
leaq 0x9f22(%rip), %rax      # 0x14760
testb $0x1, 0x50(%rax)
je 0xa853
movq 0x2e0(%r14), %rdi
movq %rbx, %rsi
callq 0xa170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x30(%rdi), %r14
callq 0x6b6a
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
movq %rax, %rbx
leaq 0x99cb(%rip), %rbp      # 0x14480
pushq $0x1
popq %r15
pushq $0x33
popq %r12
movq %r13, 0x10(%rsp)
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xab08
movl $0x98, %esi
movq %r15, %rdi
callq 0x6032
movq %rax, %r13
leaq 0x20(%rax), %rdi
movq 0xd8(%rbp), %rsi
movq %r12, %rdx
callq 0xcd50
movq %rbp, 0x88(%r13)
andq $0x0, (%r13)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r13)
movq %r13, (%rax)
jmp 0xaabd
leaq -0x29ac(%rip), %rax     # 0x8163
movq %rax, (%rsp)
leaq 0x3e8f(%rip), %rdx      # 0xe9a9
leaq -0x2bdd(%rip), %r9      # 0x7f44
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7294
testq %rax, %rax
je 0xab88
movq 0x88(%rax), %r14
testb $0x1, 0xa8(%r14)
je 0xab54
movq %r14, %rdi
callq 0x68af
testq %rbx, %rbx
je 0xab61
movq %rbx, %rdi
callq 0x6f15
movq %r14, %rdi
callq 0x6eaa
jmp 0xab88
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r15, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x6050
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xab6b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %rbx
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0x9b9d(%rip), %r13      # 0x14760
addq $0x30, %r13
pushq $0x1
popq %r14
pushq $0x33
popq %r15
movq %r12, 0x18(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0xac1c
movl $0x98, %esi
movq %r14, %rdi
callq 0x6032
movq %rax, %r12
leaq 0x20(%rax), %rdi
leaq 0x1014(%r13), %rsi
movq %r15, %rdx
callq 0xcd50
movq %r13, 0x88(%r12)
andq $0x0, (%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
jmp 0xabcf
andq $0x0, (%rsp)
leaq 0x3d88(%rip), %rdx      # 0xe9b0
leaq -0x29b7(%rip), %r9      # 0x8278
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7294
testq %rax, %rax
je 0xac78
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0x8384
jmp 0xac78
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x6050
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xac5b
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rdi, %rbx
movq %rsi, 0x8(%rsi)
movq 0x30(%rdi), %rdi
movq 0xe0(%rbx), %rcx
andq $0x0, (%rsp)
leaq 0x3256(%rip), %rdx      # 0xe473
leaq -0x2fac(%rip), %r9      # 0x8278
pushq $0x1
popq %r8
callq 0x7294
movq %rax, %r14
cmpw $0x0, 0x92(%rax)
jne 0xb25e
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0xb24b
callq 0x6050
movq %r14, %rdi
addq $0x20, %rdi
callq 0x6055
movq %rax, 0xe0(%rbx)
movq %r14, %rdi
callq 0x6050
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34e2(%rip), %rdx      # 0xea2b
leaq 0xe(%rsp), %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
movl %r8d, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x50b0
movq %r14, %rdi
callq 0x5320
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xbad7
movl %eax, %ebp
addl $0x4, %ebp
movq 0xd8(%r15), %r12
movq %r12, %rdi
callq 0x5320
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xbad7
movl %eax, %r12d
addl $0x4, %r12d
cmpl %r12d, %ebp
cmovgl %ebp, %r12d
leaq 0xb29c(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq %rax, %r14
movq 0x20(%rbx), %rsi
movq 0x38(%r15), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x57f0
movq (%r14), %r13
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0xba35
leal (%rax,%rax), %r9d
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
callq 0x5440
leaq 0xb258(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x54c0
leaq 0xb245(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq 0x20(%rbx), %rsi
callq 0x50a0
movq 0xd8(%r15), %r14
movq %r14, %rdi
callq 0x5320
movq %rax, %r15
movq 0x20(%rbx), %r13
movq %rbx, %rdi
callq 0xba20
leal 0x1(%rax), %r9d
pushq $0x2
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r13, %rcx
movl %r8d, %r14d
callq 0xbb0c
leaq 0xe(%rsp), %rdi
callq 0x5320
movq %rax, %r15
movq 0x20(%rbx), %r13
movl %r12d, %eax
cltd
idivl %r14d
movl %eax, %r14d
pushq $-0x2
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
addl %eax, %r14d
movq %rbx, %rdi
callq 0xba35
movl %eax, %r12d
movq %rbx, %rdi
callq 0xba20
leal (%r12,%rax), %r9d
incl %r9d
movq %rbx, %rdi
leaq 0xe(%rsp), %rsi
movl %r15d, %edx
movq %r13, %rcx
movl %r14d, %r8d
callq 0xbb0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6e94
testb $0x10, 0xa8(%rbx)
jne 0xb7d8
movq 0x38(%rbx), %rdi
leaq 0xb175(%rip), %rax      # 0x16858
movq (%rax), %rdx
pushq $0x4c
popq %rsi
callq 0x847c
testl %eax, %eax
js 0xb7d8
movq 0x38(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x85b2
xorl %ebp, %ebp
leaq 0xb138(%rip), %r12      # 0x16848
leaq 0x8(%rsp), %r14
movq (%r12), %rdi
movl $0x804c, %esi           # imm = 0x804C
movq %r14, %rdx
callq 0x55c0
movl 0x8(%rsp), %eax
cmpl $0x6, %eax
je 0xb748
cmpl $0xc, %eax
je 0xb73e
cmpl $0x5, %eax
jne 0xb715
jmp 0xb7c6
movq %rbx, %rdi
callq 0x67a1
jmp 0xb715
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 0x8fe7(%rip), %r13      # 0x14760
movl 0x5c(%r13), %r8d
callq 0x71b8
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 0x71b8
addl %eax, 0x58(%rbx)
movq 0x40(%rsp), %r13
movq %r13, %rax
subq %rbp, %rax
cmpq $0x11, %rax
jb 0xb715
movq %rbx, %rdi
callq 0x677b
movq %r13, %rbp
jmp 0xb715
testq %rbp, %rbp
je 0xb7d3
movq %rbx, %rdi
callq 0x677b
callq 0x84dd
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x30(%rdi), %r14
callq 0x6b6a
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
movq %rax, %rbx
leaq 0x8c42(%rip), %r15      # 0x14480
pushq $0x1
popq %r12
movq %r13, 0x10(%rsp)
movq (%r15), %r15
testq %r15, %r15
je 0xb8aa
testb $0x1, 0xa8(%r15)
je 0xb847
movq 0xe0(%r15), %rbp
testq %rbp, %rbp
jne 0xb871
movq 0xd8(%r15), %rbp
testq %rbp, %rbp
je 0xb847
movl $0x98, %esi
movq %r12, %rdi
callq 0x6032
movq %rax, %r13
leaq 0x20(%rax), %rdi
movq %rbp, %rsi
pushq $0x33
popq %rdx
callq 0xcd50
movq %r15, 0x88(%r13)
andq $0x0, (%r13)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r13)
movq %r13, (%rax)
jmp 0xb842
cmpq $0x0, 0x8(%rsp)
je 0xb923
andq $0x0, (%rsp)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7294
testq %rax, %rax
je 0xb919
movq 0x88(%rax), %r14
movq %r14, %rdi
callq 0x68af
testq %rbx, %rbx
je 0xb8f2
movq %rbx, %rdi
callq 0x6f15
movq %r14, %rdi
callq 0x6eaa
jmp 0xb923
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r15, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x6050
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xb8fc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_menu_cmd
void
mousefunc_menu_cmd(struct client_ctx *cc, void *arg)
{
	struct screen_ctx	*sc = cc->sc;
	struct menu		*mi;
	struct menu_q		 menuq;
	struct cmd		*cmd;

	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 (TAILQ_EMPTY(&menuq))
		return;

	mi = menu_filter(sc, &menuq, NULL, NULL, 0, NULL, NULL);
	if (mi != NULL)
		u_spawn(((struct cmd *)mi->ctx)->image);
	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), %rbx
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0x8e0c(%rip), %r13      # 0x14760
addq $0x30, %r13
pushq $0x1
popq %r14
pushq $0x33
popq %r15
movq %r12, 0x18(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0xb9ad
movl $0x98, %esi
movq %r14, %rdi
callq 0x6032
movq %rax, %r12
leaq 0x20(%rax), %rdi
leaq 0x1014(%r13), %rsi
movq %r15, %rdx
callq 0xcd50
movq %r13, 0x88(%r12)
andq $0x0, (%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
jmp 0xb960
cmpq $0x0, 0x10(%rsp)
je 0xba12
andq $0x0, (%rsp)
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7294
testq %rax, %rax
je 0xba08
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0x8384
jmp 0xba12
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x6050
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xb9eb
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/font.c
// Function: font_init
void
font_init(struct screen_ctx *sc, const char *color)
{
	sc->xftdraw = XftDrawCreate(X_Dpy, sc->rootwin,
	    DefaultVisual(X_Dpy, sc->which), DefaultColormap(X_Dpy, sc->which));
	if (sc->xftdraw == NULL)
		errx(1, "XftDrawCreate");

	if (!XftColorAllocName(X_Dpy, DefaultVisual(X_Dpy, sc->which),
	    DefaultColormap(X_Dpy, sc->which), color, &sc->xftcolor))
		errx(1, "XftColorAllocName");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xadf4(%rip), %r15      # 0x16848
movq (%r15), %rdi
movq 0x18(%r14), %rsi
movq 0xe8(%rdi), %rax
movl 0x10(%r14), %ecx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rdx
movq 0x50(%rax,%rcx), %rcx
callq 0x5830
movq %rax, 0xf8(%r14)
testq %rax, %rax
je 0xbabd
movq (%r15), %rdi
movq 0xe8(%rdi), %rax
movl 0x10(%r14), %ecx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rsi
movq 0x50(%rax,%rcx), %rdx
addq $0xe8, %r14
movq %rbx, %rcx
movq %r14, %r8
callq 0x5510
testl %eax, %eax
je 0xbac6
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2f6d(%rip), %rsi      # 0xea31
jmp 0xbacd
leaq 0x2f72(%rip), %rsi      # 0xea3f
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/font.c
// Function: font_make
XftFont *
font_make(struct screen_ctx *sc, const char *name)
{
	XftFont		*fn = NULL;
	FcPattern	*pat, *patx;
	XftResult	 res;

	if ((pat = FcNameParse((const FcChar8*)name)) == NULL)
		return (NULL);

	if ((patx = XftFontMatch(X_Dpy, sc->which, pat, &res)) != NULL)
		fn = XftFontOpenPattern(X_Dpy, patx);

	FcPatternDestroy(pat);

	return (fn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5880
testq %rax, %rax
je 0xbbb8
movq %rax, %rbx
leaq 0xacb9(%rip), %r15      # 0x16848
movq (%r15), %rdi
movl 0x10(%r14), %esi
leaq 0xc(%rsp), %rcx
movq %rax, %rdx
callq 0x5460
testq %rax, %rax
je 0xbbbd
movq (%r15), %rdi
movq %rax, %rsi
callq 0x56d0
movq %rax, %r14
jmp 0xbbc0
xorl %r14d, %r14d
jmp 0xbbc8
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x5030
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/linux.c
// Function: strlcat
size_t
strlcat(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;
	size_t dlen;

	/* Find the end of dst and adjust bytes left but don't go past end */
	while (n-- != 0 && *d != '\0')
		d++;
	dlen = d - dst;
	n = siz - dlen;

	if (n == 0)
		return(dlen + strlen(s));
	while (*s != '\0') {
		if (n != 1) {
			*d++ = *s;
			n--;
		}
		s++;
	}
	*d = '\0';

	return(dlen + (s - src));	/* count does not include NUL */
}

// Assembly:
pushq %rbx
leaq (%rdi,%rdx), %rcx
movq %rdi, %rax
movq %rdx, %r8
subq $0x1, %r8
jb 0xcdb9
cmpb $0x0, (%rax)
je 0xcdb6
incq %rax
jmp 0xcda6
movq %rax, %rcx
movq %rcx, %rbx
subq %rdi, %rbx
subq %rbx, %rdx
je 0xcdf0
xorl %eax, %eax
pushq $0x1
popq %rdi
movb (%rsi,%rax), %r8b
testb %r8b, %r8b
je 0xcdeb
cmpq $0x1, %rdx
jne 0xcddd
movq %rdi, %rdx
jmp 0xcde6
movb %r8b, (%rcx)
incq %rcx
decq %rdx
incq %rax
jmp 0xcdc9
movb $0x0, (%rcx)
jmp 0xcdf8
movq %rsi, %rdi
callq 0x5320
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/linux.c
// Function: isescaped
static int
isescaped(const char *sp, const char *p, int esc)
{
	const char     *cp;
	size_t		ne;

	/* No escape character */
	if (esc == '\0')
		return 1;

	/* Count the number of escape characters that precede ours */
	for (ne = 0, cp = p; --cp >= sp && *cp == esc; ne++)
		continue;

	/* Return true if odd number of escape characters */
	return (ne & 1) != 0;
}

// Assembly:
testl %edx, %edx
je 0xd23c
decq %rsi
xorl %eax, %eax
leaq (%rsi,%rax), %rcx
cmpq %rdi, %rcx
jb 0xd238
movsbl (%rcx), %ecx
cmpl %edx, %ecx
jne 0xd238
decq %rax
jmp 0xd223
andl $0x1, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/zenlinux[P]cwm/linux.c
// Function: strtonum
long long
strtonum(const char *numstr, long long minval, long long maxval,
    const char **errstrp)
{
	long long ll = 0;
	char *ep;
	int error = 0;
	struct errval {
		const char *errstr;
		int err;
	} ev[4] = {
		{ NULL,		0 },
		{ "invalid",	EINVAL },
		{ "too small",	ERANGE },
		{ "too large",	ERANGE },
	};

	ev[0].err = errno;
	errno = 0;
	if (minval > maxval)
		error = INVALID;
	else {
		ll = strtoll(numstr, &ep, 10);
		if (numstr == ep || *ep != '\0')
			error = INVALID;
		else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
			error = TOOSMALL;
		else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
			error = TOOLARGE;
	}
	if (errstrp != NULL)
		*errstrp = ev[error].errstr;
	errno = ev[error].err;
	if (error)
		ll = 0;

	return (ll);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
andq $0x0, 0x40(%rsp)
leaq 0x1c13(%rip), %rax      # 0xee7a
leaq 0x60(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, (%rcx)
leaq 0x58(%rsp), %rbx
movl $0x16, (%rbx)
leaq 0x1bfc(%rip), %rax      # 0xee82
movq %rax, 0x30(%rsp)
pushq $0x22
popq %rax
movl %eax, 0x10(%rsp)
leaq 0x1bf3(%rip), %rcx      # 0xee8c
movq %rcx, 0x50(%rsp)
movl %eax, 0x28(%rsp)
callq 0x5580
movq %rax, %r14
movl (%rax), %eax
movl %eax, 0x18(%rsp)
andl $0x0, (%r14)
movq %r15, 0x48(%rsp)
cmpq %r15, %r12
jle 0xd2c2
xorl %eax, %eax
jmp 0xd2f2
movq %rbp, 0x20(%rsp)
leaq 0x70(%rsp), %rbp
pushq $0xa
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x57c0
movq %rax, %rcx
movq (%rbp), %rax
cmpq %r13, %rax
je 0xd2eb
cmpb $0x0, (%rax)
je 0xd317
xorl %eax, %eax
movq 0x20(%rsp), %rbp
testq %rbp, %rbp
je 0xd303
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rbp)
movl (%rbx), %ecx
movl %ecx, (%r14)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rax), %rdx
cmpq %rdx, %rcx
jne 0xd342
cmpl $0x22, (%r14)
sete %al
cmpq %rdx, %r12
setne %dl
orb %al, %dl
movq 0x20(%rsp), %rbp
jne 0xd34c
jmp 0xd384
cmpq %r12, %rcx
movq 0x20(%rsp), %rbp
jge 0xd358
leaq 0x10(%rsp), %rbx
leaq 0x30(%rsp), %rax
jmp 0xd395
cmpq %rax, %rcx
jne 0xd384
cmpl $0x22, (%r14)
sete %cl
cmpq %rax, 0x48(%rsp)
setne %dl
orb %cl, %dl
jne 0xd38b
leaq 0x18(%rsp), %rbx
leaq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rsp)
jmp 0xd2f2
cmpq 0x48(%rsp), %rcx
jle 0xd39f
leaq 0x28(%rsp), %rbx
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xd2be
leaq 0x18(%rsp), %rbx
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rcx, %rax
jmp 0xd2f2