LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xd145(%rip), %rax      # 0x1a6c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd5a6
movq -0x18(%rbp), %rsi
leaq 0xd12c(%rip), %rdi      # 0x1a6c0
callq 0xc8a0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd582
movq -0x10(%rbp), %rdi
callq 0x5110
leaq 0xd10a(%rip), %rax      # 0x1a6c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd5e1
movq -0x18(%rbp), %rsi
leaq 0xd0f1(%rip), %rdi      # 0x1a6c0
callq 0xc840
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd5bd
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movl 0xf1eb(%rip), %eax      # 0x1c7ec
cmpl $0x0, %eax
jne 0xd678
leaq 0xf19b(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x5450
movl -0xc0(%rbp), %eax
leaq 0xf1b3(%rip), %rcx      # 0x1c7dc
subl (%rcx), %eax
cmpl $0x0, %eax
jne 0xd63e
leaq -0xc0(%rbp), %rdi
callq 0xd690
jmp 0xd676
cmpl $0x24, -0xc0(%rbp)
jge 0xd674
movslq -0xc0(%rbp), %rcx
leaq 0xceab(%rip), %rax      # 0x1a500
cmpq $0x0, (%rax,%rcx,8)
je 0xd674
movslq -0xc0(%rbp), %rcx
leaq -0xc0(%rbp), %rdi
leaq 0xce8f(%rip), %rax      # 0x1a500
callq *(%rax,%rcx,8)
jmp 0xd676
jmp 0xd5fb
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_randr
static void
xev_handle_randr(XEvent *ee)
{
	XRRScreenChangeNotifyEvent	*rev = (XRRScreenChangeNotifyEvent *)ee;
	struct screen_ctx		*sc;
	int				 i;

	i = XRRRootToScreen(X_Dpy, rev->root);
	TAILQ_FOREACH(sc, &Screenq, entry) {
		if (sc->which == (u_int)i) {
			XRRUpdateConfiguration(ee);
			screen_update_geometry(sc);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf0fd(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x5730
movl %eax, -0x1c(%rbp)
leaq 0xbdab(%rip), %rax      # 0x19470
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd700
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xd6f1
movq -0x8(%rbp), %rdi
callq 0x55a0
movq -0x18(%rbp), %rdi
callq 0x6250
jmp 0xd6f3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd6cc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x2c8(%rax)
movq -0x8(%rbp), %rcx
addq $0x2c8, %rcx            # imm = 0x2C8
movq -0x8(%rbp), %rax
movq %rcx, 0x2d0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2d8(%rax)
movq -0x8(%rbp), %rdi
callq 0xd8d0
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0xd88a
jmp 0xd76b
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
addq $0x118, %rcx            # imm = 0x118
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x24(%rax)
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rcx
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x118, %rcx            # imm = 0x118
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x118, %rcx            # imm = 0x118
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2d0(%rax)
jmp 0xd87c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd75f
movq -0x8(%rbp), %rdi
callq 0xb7a0
movq -0x8(%rbp), %rdi
callq 0xb800
movq -0x8(%rbp), %rdi
callq 0xb860
movq -0x8(%rbp), %rdi
callq 0xb8c0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdaa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x6460
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x5520
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xdb50
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdb8a
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xdbf7
cmpl $0x9, -0xc(%rbp)
jl 0xdc0d
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0x6d54(%rip), %rsi      # 0x1495a
movb $0x0, %al
callq 0x54b0
movq -0x18(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xdc39
jmp 0xdc66
movq -0x20(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0xdc59
movq -0x8(%rbp), %rdi
callq 0x7370
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xdc70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdc8e
cmpq $0x0, -0x8(%rbp)
jne 0xdca1
movl $0x1, %edi
leaq 0x6d95(%rip), %rsi      # 0x14a2f
movb $0x0, %al
callq 0x56f0
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xdcb7
jmp 0xdd69
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0xdd14
jmp 0xdcc7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdce8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xdcff
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
jmp 0xdd14
jmp 0xdd16
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rdi
callq 0xb9b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
jne 0xddc1
movq -0x8(%rbp), %rdi
callq 0xddf0
movq -0x8(%rbp), %rax
movl $0x2, 0xb8(%rax)
jmp 0xdddc
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xdc70
movq -0x8(%rbp), %rax
movl $0x1, 0xb8(%rax)
movq -0x8(%rbp), %rdi
callq 0x7210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/group.c
// Function: group_remove
static void
group_remove(struct client_ctx *cc)
{
	if (cc == NULL || cc->group == NULL)
		errx(1, "group_remove: a ctx is NULL");

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

	xu_ewmh_net_wm_desktop(cc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xde11
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xde24
movl $0x1, %edi
leaq 0x6c2b(%rip), %rsi      # 0x14a48
movb $0x0, %al
callq 0x56f0
jmp 0xde26
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xde47
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xde5e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x8(%rbp), %rdi
callq 0xb9b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xdedb
cmpl $0x9, -0xc(%rbp)
jl 0xdef1
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0x6a9b(%rip), %rsi      # 0x14985
movb $0x0, %al
callq 0x54b0
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdf60
movq -0x18(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0xdf2c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdff0
jmp 0xdf53
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe190
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdf51
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xdaa0
jmp 0xdf53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/group.c
// Function: group_fix_hidden_state
static void
group_fix_hidden_state(struct group_ctx *gc)
{
	struct client_ctx	*cc;
	int			 same = 0;

	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
		if (gc->hidden == ((cc->flags & CLIENT_HIDDEN) ? 1 : 0))
			same++;
	}

	if (same == 0)
		gc->hidden = !gc->hidden;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdfc0
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0xa8(%rcx), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0xdfb0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xdfb2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xdf7b
cmpl $0x0, -0x14(%rbp)
jne 0xdfdf
movq -0x8(%rbp), %rax
cmpl $0x0, 0x24(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x60c0
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe21c
movq -0x18(%rbp), %rdi
callq 0x7370
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0xe20c
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0xe20e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe1cb
movq -0x10(%rbp), %rax
movl $0x1, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xe24b
cmpl $0x9, -0xc(%rbp)
jl 0xe261
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0x6755(%rip), %rsi      # 0x149af
movb $0x0, %al
callq 0x54b0
movl $0x0, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jge 0xe2c3
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0xe297
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movslq -0x10(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0xdff0
jmp 0xe2b6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movslq -0x10(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0xe190
jmp 0xe2b8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe268
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2e0(%rax)
je 0xe2f7
jmp 0xe316
leaq 0x66d5(%rip), %rdi      # 0x149d3
leaq 0x66e7(%rip), %rsi      # 0x149ec
movl $0x131, %edx            # imm = 0x131
leaq 0x66e3(%rip), %rcx      # 0x149f4
callq 0x5190
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe345
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xe350
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe399
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe382
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xe391
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jne 0xe3ac
jmp 0xe3e6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe3c8
cmpq $0x0, -0x20(%rbp)
jne 0xe3c8
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xe3e1
movq -0x18(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0xe3df
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe190
jmp 0xe3e1
jmp 0xe325
cmpq $0x0, -0x20(%rbp)
jne 0xe3ef
jmp 0xe432
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rsi
callq 0xe190
movq -0x20(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0xe41c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xdff0
jmp 0xe432
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xdaa0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/group.c
// Function: group_client_delete
void
group_client_delete(struct client_ctx *cc)
{
	if (cc->group == NULL)
		return;

	TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
	cc->group = NULL; /* he he */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xe458
jmp 0xe4b4
jmp 0xe45a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe47b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xe492
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0xe753
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2d8(%rax)
je 0xe727
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0xdff0
jmp 0xe746
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0xe190
jmp 0xe748
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe6f3
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2d8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2d8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0xe7bb
movq -0x8(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0xe7c0
jmp 0xe923
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0xad31(%rip), %rax      # 0x19500
movq 0xd8(%rax), %rsi
movl $0x6, %edx
movl $0x1, %ecx
leaq -0x30(%rbp), %r8
callq 0xaf70
cmpl $0x0, %eax
jle 0xe83d
movq -0x30(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
jne 0xe805
movl $0x0, -0x24(%rbp)
jmp 0xe832
movq -0x30(%rbp), %rax
cmpq $0x9, (%rax)
jg 0xe819
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jge 0xe822
movl $0x8, -0x24(%rbp)
jmp 0xe830
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movl %eax, -0x24(%rbp)
jmp 0xe832
movq -0x30(%rbp), %rdi
callq 0x5060
jmp 0xe8b5
leaq 0xbe7c(%rip), %rax      # 0x1a6c0
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe8b3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rsi
callq 0x5610
cmpl $0x0, %eax
jne 0xe8a4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe898
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rsi
callq 0x5610
cmpl $0x0, %eax
jne 0xe8a4
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xe8b3
jmp 0xe8a6
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe84c
jmp 0xe8b5
cmpl $0x0, -0x24(%rbp)
jne 0xe8bd
jmp 0xe923
movq -0x10(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe8fd
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0xe8ee
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xdc70
jmp 0xe923
jmp 0xe8f0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe8cc
leaq 0xbdbc(%rip), %rax      # 0x1a6c0
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xe923
movq -0x10(%rbp), %rax
movq 0x2e0(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xdc70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/group.c
// Function: group_set_names
static void
group_set_names(struct screen_ctx *sc)
{
	char	*p, *q;
	size_t	 len = 0, tlen, slen;
	int	 i;

	for (i = 0; i < sc->group_nonames; i++)
		len += strlen(sc->group_names[i]) + 1;
	q = p = xcalloc(len, sizeof(*p));

	tlen = len;
	for (i = 0; i < sc->group_nonames; i++) {
		slen = strlen(sc->group_names[i]) + 1;
		(void)strlcpy(q, sc->group_names[i], tlen);
		tlen -= slen;
		q += slen;
	}

	xu_ewmh_net_desktop_names(sc, (unsigned char *)p, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2dc(%rcx), %eax
jge 0xe989
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5320
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xe94b
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x6460
movq %rax, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2dc(%rcx), %eax
jge 0xea23
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5320
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x12ce0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xe9ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
callq 0xb950
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x7aa0
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xa634(%rip), %rax      # 0x19480
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeed2
movl $0x1, %edi
movl $0x98, %esi
callq 0x6460
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rsi
movl $0x33, %edx
callq 0x12ce0
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xeec5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xee53
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq 0x5bb4(%rip), %rdx      # 0x14a95
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
leaq -0x4e3f(%rip), %r9      # 0xa0b0
leaq -0x4a66(%rip), %rax     # 0xa490
movq %rax, (%rsp)
callq 0x8a30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xef4c
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xef33
movq -0x8(%rbp), %rdi
callq 0x73f0
cmpq $0x0, -0x20(%rbp)
je 0xef43
movq -0x20(%rbp), %rdi
callq 0x8260
movq -0x8(%rbp), %rdi
callq 0x81d0
jmp 0xef4e
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xefa6
jmp 0xef5e
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xef7d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xef89
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x64b0
jmp 0xef4e
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xb6dd(%rip), %rax      # 0x1a6c0
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf06a
movl $0x1, %edi
movl $0x98, %esi
callq 0x6460
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
addq $0x1014, %rsi           # imm = 0x1014
movl $0x33, %edx
callq 0x12ce0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf05d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xefeb
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq 0x5a23(%rip), %rdx      # 0x14a9c
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
leaq -0x4a47(%rip), %r9      # 0xa640
movq $0x0, (%rsp)
callq 0x8a30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf0b2
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0xa850
jmp 0xf0b4
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf10c
jmp 0xf0c4
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf0e3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xf0ef
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x64b0
jmp 0xf0b4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
leaq -0x28(%rbp), %rsi
leaq 0x4b1a(%rip), %rdx      # 0x145d8
movl $0x1, %r8d
leaq -0x548b(%rip), %r9      # 0xa640
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x8a30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpw $0x0, 0x92(%rax)
jne 0xfb25
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0xfb0a
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x64b0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x18(%rbp), %rdi
callq 0x64b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_sweep_calc
static int
mousefunc_sweep_calc(struct client_ctx *cc, int x, int y, int mx, int my)
{
	int	 width = cc->geom.w, height = cc->geom.h;

	cc->geom.w = abs(x - mx) - cc->bwidth;
	cc->geom.h = abs(y - my) - cc->bwidth;

	client_applysizehints(cc);

	cc->geom.x = x <= mx ? x : x - cc->geom.w;
	cc->geom.y = y <= my ? y : y - cc->geom.h;

	return (width != cc->geom.w || height != cc->geom.h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %eax
negl %eax
cmovnsl %eax, %ecx
movq -0x8(%rbp), %rax
subl 0x50(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x5c(%rax)
movl -0x10(%rbp), %ecx
subl -0x18(%rbp), %ecx
movl %ecx, %eax
negl %eax
cmovnsl %eax, %ecx
movq -0x8(%rbp), %rax
subl 0x50(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
callq 0x85d0
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x102ec
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x102f9
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x5c(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x10313
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x10320
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x60(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rdx
movb $0x1, %al
cmpl 0x5c(%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x1034b
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x9e8d(%rip), %rax      # 0x1a6c0
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x108ba
movl $0x1, %edi
movl $0x98, %esi
callq 0x6460
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
addq $0x1014, %rsi           # imm = 0x1014
movl $0x33, %edx
callq 0x12ce0
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x108ad
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1083b
cmpq $0x0, -0x30(%rbp)
jne 0x108c6
jmp 0x10966
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
xorl %r8d, %r8d
movq %r9, %rdx
movq %r9, %rcx
movq $0x0, (%rsp)
callq 0x8a30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1090a
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0xa850
jmp 0x10966
jmp 0x1090c
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x10964
jmp 0x1091c
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1093b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x10947
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x64b0
jmp 0x1090c
jmp 0x10966
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xbdc1(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0xbdaf(%rip), %rax      # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdx
leaq 0xbd8c(%rip), %rax      # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rcx
callq 0x5830
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x10a6c
movl $0x1, %edi
leaq 0x40bc(%rip), %rsi      # 0x14b21
movb $0x0, %al
callq 0x56f0
leaq 0xbd35(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
leaq 0xbd2b(%rip), %rax      # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rsi
leaq 0xbd08(%rip), %rax      # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0xe8, %r8
callq 0x5510
cmpl $0x0, %eax
jne 0x10ae8
movl $0x1, %edi
leaq 0x404e(%rip), %rsi      # 0x14b2f
movb $0x0, %al
callq 0x56f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/font.c
// Function: font_width
int
font_width(struct screen_ctx *sc, const char *text, int len)
{
	XGlyphInfo	 extents;

	XftTextExtentsUtf8(X_Dpy, sc->font, (const FcChar8*)text,
	    len, &extents);

	return (extents.xOff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xbc9e(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x20(%rbp), %r8
callq 0x5680
movswl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5880
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x10be5
movq $0x0, -0x8(%rbp)
jmp 0x10c35
leaq 0xbbbc(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x28(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x5460
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x10c24
leaq 0xbb94(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x56d0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
je 0x12e06
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x12e0f
jmp 0x12e1d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12ddc
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x12e60
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5320
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x12ec3
jmp 0x12e62
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x12ea6
cmpq $0x1, -0x38(%rbp)
je 0x12e98
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12e62
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x134ee
movl $0x1, -0x4(%rbp)
jmp 0x13555
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
jb 0x13525
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x1c(%rbp), %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1352e
jmp 0x1353e
jmp 0x13530
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x134fe
movq -0x30(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x574b(%rip), %rsi      # 0x18ce0
movl $0x40, %edx
callq 0x5860
callq 0x5580
movl (%rax), %eax
movl %eax, -0x78(%rbp)
callq 0x5580
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x135ca
movl $0x1, -0x34(%rbp)
jmp 0x1365d
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x57c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x135f6
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x135ff
movl $0x1, -0x34(%rbp)
jmp 0x1365b
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x28(%rbp)
jne 0x13619
callq 0x5580
cmpl $0x22, (%rax)
je 0x13623
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x1362c
movl $0x2, -0x34(%rbp)
jmp 0x13659
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x28(%rbp)
jne 0x13646
callq 0x5580
cmpl $0x22, (%rax)
je 0x13650
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x13657
movl $0x3, -0x34(%rbp)
jmp 0x13659
jmp 0x1365b
jmp 0x1365d
cmpq $0x0, -0x20(%rbp)
je 0x1367d
movslq -0x34(%rbp), %rcx
leaq -0x80(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0x34(%rbp), %rcx
leaq -0x80(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x84(%rbp)
callq 0x5580
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x34(%rbp)
je 0x136b0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq