LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zenlinux[P]cwm/conf.c
// Function: conf_mousebind
void
conf_mousebind(struct conf *c, char *name, char *binding)
{
	struct mousebinding	*current_binding;
	char			*substring, *tmp;
	const char		*errstr;
	int			 iter;

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

	if ((substring = strchr(name, '-')) != NULL) {
		for (iter = 0; iter < nitems(bind_mods); iter++) {
			if ((tmp = strchr(name, bind_mods[iter].chr)) !=
			    NULL && tmp < substring) {
				current_binding->modmask |=
				    bind_mods[iter].mask;
			}
		}

		/* skip past the modifiers */
		substring++;
	} else
		substring = name;

	current_binding->button = strtonum(substring, 1, 3, &errstr);
	if (errstr)
		warnx("number of buttons is %s: %s", errstr, substring);

	conf_mouseunbind(c, current_binding);

	if (strcmp("unmap", binding) == 0)
		return;

	for (iter = 0; iter < nitems(name_to_mousefunc); iter++) {
		if (strcmp(name_to_mousefunc[iter].tag, binding) != 0)
			continue;

		current_binding->context = name_to_mousefunc[iter].context;
		current_binding->callback = name_to_mousefunc[iter].handler;
		TAILQ_INSERT_TAIL(&c->mousebindingq, current_binding, entry);
		return;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
movl $0x1, %edi
movl $0x28, %esi
callq 0x6198
movq %rax, %r14
movq %r12, %rdi
movl $0x2d, %esi
callq 0x5520
testq %rax, %rax
je 0x96e5
movq %rax, %r13
movq %rbp, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x5113(%rip), %rbx      # 0xe7c0
movsbl (%rbx,%rbp,8), %esi
movq %r12, %rdi
callq 0x5520
testq %rax, %rax
sete %cl
cmpq %r13, %rax
setae %al
orb %cl, %al
jne 0x96d1
movl 0x4(%rbx,%rbp,8), %eax
orl %eax, 0x18(%r14)
incq %rbp
cmpq $0x4, %rbp
jne 0x96ad
incq %r13
movq %r13, %r12
movq 0x8(%rsp), %rbp
leaq 0x10(%rsp), %r13
movl $0x1, %esi
movl $0x3, %edx
movq %r12, %rdi
movq %r13, %rcx
callq 0xd73b
movl %eax, 0x1c(%r14)
movq (%r13), %rsi
testq %rsi, %rsi
je 0x971d
leaq 0x4c9d(%rip), %rdi      # 0xe3b0
movq %r12, %rdx
xorl %eax, %eax
callq 0x5140
movq 0x40(%rbp), %r12
testq %r12, %r12
je 0x9763
leaq 0x48(%rbp), %r13
movq %r12, %rdi
movq (%r12), %r12
movl 0x18(%rdi), %eax
cmpl 0x18(%r14), %eax
jne 0x975e
movl 0x1c(%rdi), %eax
cmpl 0x1c(%r14), %eax
jne 0x975e
leaq 0x8(%r12), %rax
testq %r12, %r12
movq 0x8(%rdi), %rcx
cmoveq %r13, %rax
movq %rcx, (%rax)
movq %r12, (%rcx)
callq 0x61b8
testq %r12, %r12
jne 0x972a
leaq 0x4c40(%rip), %rdi      # 0xe3aa
movq %r15, %rsi
callq 0x5610
testl %eax, %eax
je 0x97c9
movl $0x10, %ebx
leaq 0x99ce(%rip), %r12      # 0x13150
movq -0x10(%rbx,%r12), %rdi
movq %r15, %rsi
callq 0x5610
testl %eax, %eax
je 0x97a2
addq $0x18, %rbx
cmpq $0xe8, %rbx
jne 0x9782
jmp 0x97c9
movl (%rbx,%r12), %eax
movl %eax, 0x20(%r14)
movq -0x8(%rbx,%r12), %rax
movq %rax, 0x10(%r14)
movq $0x0, (%r14)
movq 0x48(%rbp), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x48(%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenlinux[P]cwm/conf.c
// Function: conf_clear
void
conf_clear(struct conf *c)
{
	struct autogroupwin	*ag;
	struct keybinding	*kb;
	struct winmatch		*wm;
	struct cmd		*cmd;
	struct mousebinding	*mb;
	int			 i;

	while ((cmd = TAILQ_FIRST(&c->cmdq)) != NULL) {
		TAILQ_REMOVE(&c->cmdq, cmd, entry);
		xfree(cmd);
	}

	while ((kb = TAILQ_FIRST(&c->keybindingq)) != NULL) {
		TAILQ_REMOVE(&c->keybindingq, kb, entry);
		xfree(kb);
	}

	while ((ag = TAILQ_FIRST(&c->autogroupq)) != NULL) {
		TAILQ_REMOVE(&c->autogroupq, ag, entry);
		xfree(ag->class);
		if (ag->name)
			xfree(ag->name);
		xfree(ag);
	}

	while ((wm = TAILQ_FIRST(&c->ignoreq)) != NULL) {
		TAILQ_REMOVE(&c->ignoreq, wm, entry);
		xfree(wm);
	}

	while ((mb = TAILQ_FIRST(&c->mousebindingq)) != NULL) {
		TAILQ_REMOVE(&c->mousebindingq, mb, entry);
		xfree(mb);
	}

	for (i = 0; i < CWM_COLOR_MAX; i++)
		xfree(c->color[i].name);

	xfree(c->font);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x9832
leaq 0x38(%rbx), %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
jne 0x97ed
jmp 0x9832
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %rbx, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x9815
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x9887
leaq 0x18(%rbx), %r15
movq (%r14), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %r15, %rcx
movq 0x8(%r14), %rdx
movq %rdx, (%rcx)
movq %rax, (%rdx)
movq 0x10(%r14), %rdi
callq 0x61b8
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x9876
callq 0x61b8
movq %r14, %rdi
callq 0x61b8
movq 0x10(%rbx), %r14
testq %r14, %r14
jne 0x9847
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x98ba
leaq 0x28(%rbx), %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x9894
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x98ed
leaq 0x48(%rbx), %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x98c7
xorl %r14d, %r14d
movq 0x70(%rbx,%r14), %rdi
callq 0x61b8
addq $0x10, %r14
cmpq $0x70, %r14
jne 0x98f0
movq 0x20e0(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x61b8
// File: /workspace/github_c_makefile_star2_O3/zenlinux[P]cwm/conf.c
// Function: conf_setup
void
conf_setup(struct conf *c, const char *conf_file)
{
	char		 conf_path[MAXPATHLEN];
	char		*home;
	struct stat	 sb;
	int		 parse = 0;

	conf_init(c);

	if (conf_file == NULL) {
		if ((home = getenv("HOME")) == NULL)
			errx(1, "No HOME directory.");

		(void)snprintf(conf_path, sizeof(conf_path), "%s/%s",
		    home, CONFFILE);

		if (stat(conf_path, &sb) == 0 && (sb.st_mode & S_IFREG))
			parse = 1;
	} else {
		if (stat(conf_file, &sb) == -1 || !(sb.st_mode & S_IFREG))
			errx(1, "%s: %s", conf_file, strerror(errno));
		else {
			(void)strlcpy(conf_path, conf_file, sizeof(conf_path));
			parse = 1;
		}
	}

	if (parse && (parse_config(conf_path, c) == -1))
		warnx("config file %s has errors, not loading", conf_path);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9347
testq %r14, %r14
je 0x9990
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5840
cmpl $-0x1, %eax
je 0x99ea
testb $-0x80, 0x19(%rsp)
je 0x99ea
leaq 0x90(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0xd220
leaq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0xcfc5
cmpl $-0x1, %eax
jne 0x99df
leaq 0x49ff(%rip), %rdi      # 0xe37e
leaq 0x90(%rsp), %rsi
xorl %eax, %eax
callq 0x5140
jmp 0x99df
leaq 0x49c2(%rip), %rdi      # 0xe359
callq 0x5550
testq %rax, %rax
je 0x9a0f
leaq 0x49c9(%rip), %rdx      # 0xe371
leaq 0x49c8(%rip), %r8       # 0xe377
leaq 0x90(%rsp), %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x50b0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5840
testl %eax, %eax
jne 0x99df
testb $-0x80, 0x19(%rsp)
jne 0x9963
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r14
retq
callq 0x5580
movl (%rax), %edi
callq 0x5490
leaq 0x49c8(%rip), %rsi      # 0xe3c5
movl $0x1, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x56f0
leaq 0x4948(%rip), %rsi      # 0xe35e
movl $0x1, %edi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O3/zenlinux[P]cwm/conf.c
// Function: conf_client
void
conf_client(struct client_ctx *cc)
{
	struct winmatch	*wm;
	char		*wname = cc->name;
	int		 ignore = 0;

	TAILQ_FOREACH(wm, &Conf.ignoreq, entry) {
		if (strncasecmp(wm->title, wname, strlen(wm->title)) == 0) {
			ignore = 1;
			break;
		}
	}

	cc->bwidth = ignore ? 0 : Conf.bwidth;
	cc->flags |= ignore ? CLIENT_IGNORE : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xad29(%rip), %r12      # 0x14760
leaq 0x20(%r12), %r13
movq 0xd8(%rdi), %r14
xorl %ebp, %ebp
movq (%r13), %r13
testq %r13, %r13
je 0x9a73
leaq 0x10(%r13), %r15
movq %r15, %rdi
callq 0x5320
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x55d0
testl %eax, %eax
jne 0x9a45
movl $0x2, %eax
jmp 0x9a75
xorl %eax, %eax
testq %r13, %r13
jne 0x9a7f
movl 0x54(%r12), %ebp
movl %ebp, 0x50(%rbx)
orl %eax, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac53(%rip), %rax      # 0x14760
movq 0x40(%rax), %r15
testq %r15, %r15
je 0x9b54
movq %rdi, %rbx
leaq 0x48ac(%rip), %r14      # 0xe3cc
cmpl $0x2, 0x20(%r15)
jne 0x9b4c
movl 0x1c(%r15), %edx
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x9b42
movq 0x38(%rbx), %rdi
movl 0x18(%r15), %esi
callq 0x8791
jmp 0x9b4c
movq %r14, %rdi
xorl %eax, %eax
callq 0x5140
movq (%r15), %r15
testq %r15, %r15
jne 0x9b20
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xccd6(%rip), %r15      # 0x16848
movq (%r15), %rdi
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5260
movq %rax, %r14
movq (%r15), %rdi
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x5260
movl 0x50(%rbx), %ecx
andl $-0x13, %ecx
movl %ecx, 0x50(%rbx)
leaq 0xabb8(%rip), %rdx      # 0x14760
movq (%rdx), %r15
testq %r15, %r15
je 0x9c3b
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 0x9bfc
movl 0x28(%r15), %edi
testl %edi, %edi
sete %r8b
testl %esi, %esi
setne %sil
orb %r8b, %sil
jne 0x9bf2
cmpl 0x54(%rbx), %edi
je 0x9c01
cmpq %rdx, %r14
je 0x9c01
cmpq %rdx, %rax
je 0x9c01
movq (%r15), %r15
jmp 0x9bab
testb $0x1, 0x2c(%r15)
movq 0x20(%rbx), %rdi
jne 0x9c1c
callq 0x5fb4
leaq 0x8(%rsp), %rdi
movq %rax, 0x30(%rdi)
jmp 0x9c33
callq 0x61e0
testq %rax, %rax
jne 0x9c30
callq 0x6d39
testq %rax, %rax
je 0x9c3b
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_O3/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 0x5fb4
movq %rax, %rbx
callq 0x6d39
movq %rax, %r14
leaq 0xcbdd(%rip), %rax      # 0x16848
movq (%rax), %rdi
movzbl 0x54(%r15), %esi
xorl %r15d, %r15d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5260
cltq
leaq 0x4b58(%rip), %rcx      # 0xe7e0
cmpq (%r15,%rcx), %rax
je 0x9c9e
addq $0x8, %r15
cmpq $0x30, %r15
jne 0x9c88
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7256
// File: /workspace/github_c_makefile_star2_O3/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 0x5fb4
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x61e0
movl 0x50(%rbx), %ecx
andl $-0x13, %ecx
movl %ecx, 0x50(%rbx)
leaq 0xaa7e(%rip), %rdx      # 0x14760
movq 0x40(%rdx), %r15
testq %r15, %r15
je 0x9d37
movl 0x54(%rbx), %edx
cmpl 0x1c(%r15), %edx
jne 0x9cfa
cmpl 0x18(%r15), %ecx
je 0x9d04
movq (%r15), %r15
testq %r15, %r15
jne 0x9cee
jmp 0x9d37
cmpl $0x1, 0x20(%r15)
jne 0x9d28
movq 0x20(%rbx), %rdi
cmpq 0x18(%r14), %rdi
jne 0x9d37
callq 0x5fb4
movq %rax, %rcx
leaq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x9d2d
testq %rax, %rax
je 0x9d37
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_O3/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 0xca75(%rip), %r15      # 0x16848
movq (%r15), %rdi
callq 0x5120
movq 0x28(%rbx), %rdi
callq 0x61e0
testq %rax, %rax
je 0x9e12
movq %rax, %r14
movq (%r15), %rdi
movq 0x38(%rax), %rsi
movq %rsp, %rcx
movl $0x11, %edx
callq 0x5100
testl %eax, %eax
jne 0x9e0a
cmpl $0x0, 0x10(%rbx)
je 0x9e27
movq %r14, %rdi
callq 0x6aa3
movq (%r15), %rdi
callq 0x5420
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x6a0f
jmp 0x9e12
// File: /workspace/github_c_makefile_star2_O3/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 0x6d39
testq %rax, %rax
je 0x9e50
movq %rax, %rdi
callq 0x7104
movq 0x28(%rbx), %rdi
callq 0x61e0
testq %rax, %rax
jne 0x9e94
leaq 0xc9e3(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x5710
movq 0x28(%rbx), %rbx
movq 0x20(%r14), %rdi
callq 0x5fb4
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x61f6
testb $0x2, 0xa8(%rax)
jne 0x9ea5
movq %rax, %rdi
callq 0x7088
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61e0
testq %rax, %rax
je 0x9f73
movq %rax, %rbx
movq 0x58(%r14), %rdx
testb $0x4, %dl
je 0x9edf
movl 0x38(%r14), %eax
movl %eax, 0x5c(%rbx)
testb $0x8, %dl
je 0x9eeb
movl 0x3c(%r14), %eax
movl %eax, 0x60(%rbx)
testb $0x1, %dl
je 0x9ef7
movl 0x30(%r14), %eax
movl %eax, 0x54(%rbx)
testb $0x2, %dl
je 0x9f03
movl 0x34(%r14), %eax
movl %eax, 0x58(%rbx)
movq 0x30(%rbx), %rcx
movl 0x54(%rbx), %eax
testl %eax, %eax
jne 0x9f23
movl 0x5c(%rbx), %esi
xorl %eax, %eax
cmpl 0xac(%rcx), %esi
jl 0x9f23
xorl %eax, %eax
subl 0x50(%rbx), %eax
movl %eax, 0x54(%rbx)
movl 0x58(%rbx), %edi
movl 0x60(%rbx), %esi
testl %edi, %edi
jne 0x9f3f
xorl %edi, %edi
cmpl 0xb0(%rcx), %esi
jl 0x9f3f
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 0xc8eb(%rip), %rax      # 0x16848
movq (%rax), %rdi
movq 0x38(%rbx), %rsi
callq 0x50e0
movq %rbx, %rdi
callq 0x89fb
jmp 0x9fab
movups 0x30(%r14), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%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 0xc8a5(%rip), %rax      # 0x16848
movq (%rax), %rdi
callq 0x50e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61e0
testq %rax, %rax
je 0x9fe4
movq 0x28(%rbx), %rcx
cmpq $0x27, %rcx
je 0xa022
cmpq $0x44, %rcx
je 0xa019
cmpq $0x28, %rcx
jne 0xa017
movq %rax, %rdi
popq %rbx
jmp 0x6690
leaq 0xa485(%rip), %rdi      # 0x14470
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa017
movq 0x18(%rdi), %rax
cmpq 0x20(%rbx), %rax
jne 0x9feb
movq 0x28(%rbx), %rax
leaq 0xa4e8(%rip), %rcx      # 0x144f0
cmpq 0xa8(%rcx), %rax
jne 0xa017
popq %rbx
jmp 0xa272
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x69a3
movq %rax, %rdi
popq %rbx
jmp 0x6799
// File: /workspace/github_c_makefile_star2_O3/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 0xc80f(%rip), %rax      # 0x16848
movq (%rax), %rdi
leaq 0x47cd(%rip), %rsi      # 0xe810
xorl %edx, %edx
callq 0x5690
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x61e0
testq %rax, %rax
je 0xa07d
cmpq %r14, 0x28(%rbx)
jne 0xa07d
cmpl $0x20, 0x30(%rbx)
jne 0xa07d
cmpq $0x3, 0x38(%rbx)
jne 0xa07d
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a0f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa6c9(%rip), %r12      # 0x14760
movq (%r12), %r14
testq %r14, %r14
je 0xa0ba
leaq 0xa6b9(%rip), %r15      # 0x14760
movq %r15, %rdi
movq %r14, %rsi
callq 0x9acc
movq (%r14), %r14
testq %r14, %r14
jne 0xa0a7
movq %rbx, %rdi
callq 0x5110
movq (%r12), %rbx
testq %rbx, %rbx
je 0xa0e5
leaq 0xa68e(%rip), %r14      # 0x14760
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a97
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xa0d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xc794(%rip)      # 0x1688c
je 0xa0fb
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0xc735(%rip), %r15      # 0x16848
leaq 0x8(%rsp), %rbx
leaq 0xc75d(%rip), %r12      # 0x1687c
leaq 0xa34a(%rip), %r13      # 0x14470
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5450
movslq 0x8(%rsp), %rax
cmpl (%r12), %eax
jne 0xa174
movq (%r15), %rdi
movq 0x30(%rsp), %rsi
callq 0x5730
movq (%r13), %r14
testq %r14, %r14
je 0xa18e
movl %eax, %ebp
cmpl %ebp, 0x10(%r14)
jne 0xa16a
movq %rbx, %rdi
callq 0x55a0
movq %r14, %rdi
callq 0x60a3
movq (%r14), %r14
testq %r14, %r14
jne 0xa154
jmp 0xa18e
cmpl $0x23, %eax
jg 0xa18e
leaq 0xa450(%rip), %rcx      # 0x145d0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0xa18e
movq %rbx, %rdi
callq *%rax
cmpl $0x0, 0xc6f7(%rip)      # 0x1688c
je 0xa126
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c8(%rdi), %rax
movq $0x0, 0x2c8(%rdi)
movq %rax, 0x2d0(%rdi)
movl $0x0, 0x2d8(%rdi)
callq 0xa272
leaq 0x118(%rbx), %r14
movq 0x2d0(%rbx), %rdi
movq $-0x9, %rax
xorl %ecx, %ecx
movq %r14, %rdx
xorl %esi, %esi
leaq 0x10(%rdx), %r8
movq %rcx, 0x10(%rdx)
movq %r8, 0x18(%rdx)
movl $0x0, 0x24(%rdx)
leal 0xa(%rax), %r8d
movl %r8d, 0x20(%rdx)
movq %rcx, (%rdx)
movq %rdi, 0x8(%rdx)
movq %rdx, (%rdi)
leaq (%rsi,%rsi,2), %rdi
shlq $0x4, %rdi
addq %r14, %rdi
incq %rsi
movq %rdx, 0x2d0(%rbx)
addq $0x30, %rdx
incq %rax
jne 0xa1f7
movq %rbx, %rdi
callq 0x9005
movq %rbx, %rdi
callq 0x9047
movq %rbx, %rdi
callq 0x9087
movq %rbx, %rdi
callq 0x90c7
movq %r14, 0x2e0(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x90e4
// File: /workspace/github_c_makefile_star2_O3/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 0x6198
movq %rax, %r14
movq %r15, %rdi
movl $0x2c, %esi
callq 0x5520
testq %rax, %rax
je 0xa4bd
movq %rax, %r12
incq %r12
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x61bd
movq %rax, 0x18(%r14)
movq %r12, %rdi
jmp 0xa4c8
movq $0x0, 0x18(%r14)
movq %r15, %rdi
callq 0x61bd
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_O3/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 0xa54e
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 0xa546
cmpl $0x0, 0x24(%r14)
je 0xa537
movq %rbx, %rdi
callq 0x6a0f
incl 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa561
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x42f8(%rip), %rsi      # 0xe84d
movl $0x1, %edi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O3/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 0xa5bd
testq %rsi, %rsi
je 0xa5bd
movq 0xf0(%rsi), %rax
cmpq %rdi, %rax
je 0xa5bc
testq %rax, %rax
je 0xa592
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rdx, 0x18(%rax)
movq %rcx, (%rdx)
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 0x915c
retq
pushq %rax
leaq 0x435d(%rip), %rsi      # 0xe922
movl $0x1, %edi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O3/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 0xa5fb
movq %rbx, %rsi
callq 0xa561
movl $0x1, %eax
jmp 0xa62e
testq %rdi, %rdi
je 0xa63d
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq 0x18(%rbx), %rdx
movq %rdx, 0x18(%rax)
movq %rcx, (%rdx)
movq $0x0, 0xf0(%rbx)
movq %rbx, %rdi
callq 0x915c
movl $0x2, %eax
movl %eax, 0xb8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6936
leaq 0x42f7(%rip), %rsi      # 0xe93b
movl $0x1, %edi
xorl %eax, %eax
callq 0x56f0
// File: /workspace/github_c_makefile_star2_O3/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 0xa704
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), %rcx
movl 0x24(%r15), %eax
testq %rcx, %rcx
je 0xa6b7
xorl %edx, %edx
movl 0xa8(%rcx), %esi
andl $0x1, %esi
xorl %edi, %edi
cmpl %esi, %eax
sete %dil
addl %edi, %edx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xa697
testl %edx, %edx
jne 0xa6c4
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0x24(%r15)
movl %ecx, %eax
testl %eax, %eax
je 0xa6d5
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa717
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa83d
cmpq $0x0, 0x10(%r15)
je 0xa6ed
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x2e0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x90e4
leaq 0x416d(%rip), %rsi      # 0xe878
movl $0x1, %edi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O3/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 0xa757
xorl %ecx, %ecx
movl 0xb4(%rax), %edx
cmpl %ecx, %edx
jle 0xa747
movl %edx, 0x2c(%r14)
movl %edx, %ecx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa737
incl %ecx
movslq %ecx, %rsi
jmp 0xa75c
movl $0x1, %esi
movl $0x8, %edi
callq 0x6198
movq %rax, %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0xa799
movq 0x38(%r12), %rax
movslq 0x2c(%r14), %rcx
movslq 0xb4(%r12), %rdx
subq %rdx, %rcx
movq %rax, (%r15,%rcx,8)
movq %r12, %rdi
callq 0x6a65
movq 0x10(%r12), %r12
jmp 0xa76d
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 0xa7c4
cmpl $-0x1, %esi
jne 0xa7c4
movl %edx, %esi
jmp 0xa7dd
testq %rdi, %rdi
je 0xa7dd
cmpl $-0x1, %esi
je 0xa7dd
movslq %esi, %r8
movq %rdi, (%r15,%r8,8)
incl %esi
cmpq %rsi, %rdx
cmovel %ecx, %esi
incq %rdx
cmpq %rdx, %rax
jne 0xa7b2
leaq 0xc05c(%rip), %rax      # 0x16848
movq (%rax), %rdi
movl 0x28(%r14), %edx
movq %r15, %rsi
callq 0x5400
movq %r15, %rdi
callq 0x61b8
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 0x90e4
// File: /workspace/github_c_makefile_star2_O3/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 0x5fd5
movq $0x0, 0x28(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0xa87a
movq %r14, %rdi
callq 0x6a0f
incl 0x28(%rbx)
movl 0xb4(%r14), %eax
cmpl 0x2c(%rbx), %eax
jle 0xa874
movl %eax, 0x2c(%rbx)
movq 0x10(%r14), %r14
jmp 0xa855
movl $0x1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa8ed
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movl %edx, %r12d
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r15
addq $0x118, %r15            # imm = 0x118
xorl %r13d, %r13d
movq %rbx, %rdi
cmpq %r13, %r12
jne 0xa8ce
movq %r15, %rsi
callq 0xa717
jmp 0xa8d6
movq %r14, %rsi
callq 0xa83d
incq %r13
addq $0x30, %r14
cmpq $0x9, %r13
jne 0xa8bc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3fae(%rip), %rsi      # 0xe8a2
movl $0x1, %edi
xorl %eax, %eax
callq 0x54b0
// File: /workspace/github_c_makefile_star2_O3/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 0xa9ee
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2c8(%rdi), %r12
xorl %r14d, %r14d
testb $0x2, %bpl
jne 0xa93a
movq (%r15), %r15
movq %r12, %rax
testq %r15, %r15
jne 0xa958
jmp 0xa955
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
testq %r15, %r15
jne 0xa958
movq 0x2d0(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
movq 0x2e0(%rbx), %rsi
cmpq %rsi, %r15
je 0xa98f
testq %r14, %r14
setne %al
cmpq $0x0, 0x10(%r15)
sete %cl
orb %al, %cl
je 0xa98a
cmpl $0x0, 0x24(%r15)
jne 0xa927
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa83d
jmp 0xa927
movq %r15, %r14
jmp 0xa927
testq %r14, %r14
je 0xa9b6
movq %rbx, %rdi
callq 0xa83d
cmpl $0x0, 0x24(%r14)
je 0xa9bf
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa717
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 0x90e4
leaq 0x3ed1(%rip), %rdi      # 0xe8c6
leaq 0x3ee3(%rip), %rsi      # 0xe8df
leaq 0x3ee4(%rip), %rcx      # 0xe8e7
movl $0x131, %edx            # imm = 0x131
callq 0x5190
// File: /workspace/github_c_makefile_star2_O3/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 0x5fb4
movq %rax, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %r15
addq $0x118, %r15            # imm = 0x118
leaq 0x3ea5(%rip), %r12      # 0xe91b
leaq 0x3e95(%rip), %r13      # 0xe912
xorl %ebp, %ebp
cmpq $0x0, 0x10(%r15)
je 0xaae2
movl $0x1, %edi
movl $0x98, %esi
callq 0x6198
movq %rax, %r14
leaq 0x20(%rax), %rdi
cmpl $0x0, 0x24(%r15)
movl 0x20(%r15), %ecx
movq 0x2e8(%rbx), %rax
movq (%rax,%rbp,8), %r8
movq %r13, %rdx
cmoveq %r12, %rdx
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 0xaa7f
cmpq $0x0, 0x8(%rsp)
je 0xab6b
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 0x7473
testq %rax, %rax
je 0xab61
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0xab61
cmpl $0x0, 0x24(%rsi)
je 0xab3a
movq %rbx, %rdi
callq 0xa717
jmp 0xab61
movq %rbx, %rdi
callq 0xa83d
jmp 0xab61
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xab44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq (%rbx,%r14), %rsi
cmpl $0x0, 0x2d8(%rbx)
je 0xab9e
movq %rbx, %rdi
callq 0xa717
jmp 0xaba6
movq %rbx, %rdi
callq 0xa83d
addq $0x30, %r14
cmpq $0x2c8, %r14            # imm = 0x2C8
jne 0xab87
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_O3/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 0xace5
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x100(%rdi)
je 0xacd9
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rdi
leaq 0x98e9(%rip), %rax      # 0x144f0
movq 0xd8(%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x6, %edx
movl $0x1, %ecx
callq 0x8ac3
testl %eax, %eax
jle 0xac57
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0xac49
movl $0x8, %ebp
cmpq $0x9, %rax
ja 0xac49
incl %eax
movl %eax, %ebp
callq 0x5060
testl %ebp, %ebp
jne 0xaca7
jmp 0xacd9
leaq 0x9b02(%rip), %rax      # 0x14760
movq 0x10(%rax), %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r12, %r12
je 0xaca7
movq 0xf8(%rbx), %r14
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x5610
testl %eax, %eax
jne 0xac9e
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0xace6
movq 0x100(%rbx), %rsi
callq 0x5610
testl %eax, %eax
je 0xace6
movq (%r12), %r12
testq %r12, %r12
jne 0xac73
leaq 0x2c8(%r15), %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xacbd
cmpl %ebp, 0x20(%rdi)
jne 0xacae
jmp 0xacd1
leaq 0x9a9c(%rip), %rax      # 0x14760
testb $0x1, 0x50(%rax)
je 0xacd9
movq 0x2e0(%r15), %rdi
movq %rbx, %rsi
callq 0xa561
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r12), %ebp
jmp 0xac4e
// File: /workspace/github_c_makefile_star2_O3/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 0x6d39
movq %rax, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x952e(%rip), %rax      # 0x14480
movq (%rax), %r12
testq %r12, %r12
je 0xafa7
movl $0x1, %edi
movl $0x98, %esi
callq 0x6198
movq %rax, %r14
leaq 0x20(%rax), %rdi
movq 0xd8(%r12), %rsi
movl $0x33, %edx
callq 0xd220
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 0xaf55
leaq -0x2bf3(%rip), %rax     # 0x83bb
movq %rax, (%rsp)
leaq 0x39f0(%rip), %rdx      # 0xe9a9
leaq -0x2e10(%rip), %r9      # 0x81b0
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7473
testq %rax, %rax
je 0xb027
movq 0x88(%rax), %r15
testb $0x1, 0xa8(%r15)
je 0xaff3
movq %r15, %rdi
callq 0x6a65
testq %rbx, %rbx
je 0xb000
movq %rbx, %rdi
callq 0x7104
movq %r15, %rdi
callq 0x7088
jmp 0xb027
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xb00a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x96ff(%rip), %rax      # 0x14760
movq 0x30(%rax), %r15
testq %r15, %r15
je 0xb0b5
movl $0x1, %edi
movl $0x98, %esi
callq 0x6198
movq %rax, %r14
leaq 0x20(%rax), %rdi
leaq 0x1014(%r15), %rsi
movl $0x33, %edx
callq 0xd220
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 0xb065
movq $0x0, (%rsp)
leaq 0x38ec(%rip), %rdx      # 0xe9b0
leaq -0x2bd8(%rip), %r9      # 0x84f3
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7473
testq %rax, %rax
je 0xb114
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0x8618
jmp 0xb114
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %r14, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x61b8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xb0f7
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d72(%rip), %rdx      # 0xe473
leaq -0x3215(%rip), %r9      # 0x84f3
movl $0x1, %r8d
callq 0x7473
movq %rax, %r14
cmpw $0x0, 0x92(%rax)
jne 0xb744
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0xb731
callq 0x61b8
movq %r14, %rdi
addq $0x20, %rdi
callq 0x61bd
movq %rax, 0xe0(%rbx)
movq %r14, %rdi
callq 0x61b8
addq $0x18, %rsp
popq %rbx
popq %r14
retq