LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: x_setup
static void
x_setup(void)
{
	struct screen_ctx	*sc;
	struct keybinding	*kb;
	int			 i;

	Cursor_default = XCreateFontCursor(X_Dpy, XC_X_cursor);
	Cursor_move = XCreateFontCursor(X_Dpy, XC_fleur);
	Cursor_normal = XCreateFontCursor(X_Dpy, XC_left_ptr);
	Cursor_question = XCreateFontCursor(X_Dpy, XC_question_arrow);
	Cursor_resize = XCreateFontCursor(X_Dpy, XC_bottom_right_corner);

	for (i = 0; i < ScreenCount(X_Dpy); i++) {
		sc = xcalloc(1, sizeof(*sc));
		x_setupscreen(sc, i);
		TAILQ_INSERT_TAIL(&Screenq, sc, entry);
	}

	/*
	 * XXX key grabs weren't done before, since Screenq was empty,
	 * do them here for now (this needs changing).
	 */
	TAILQ_FOREACH(kb, &Conf.keybindingq, entry)
		conf_grab(&Conf, kb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x16ae9(%rip), %rdi     # 0x1c7a8
xorl %esi, %esi
callq 0x5050
movq %rax, 0x16ae3(%rip)     # 0x1c7b0
movq 0x16ad4(%rip), %rdi     # 0x1c7a8
movl $0x34, %esi
callq 0x5050
movq %rax, 0x16ad3(%rip)     # 0x1c7b8
movq 0x16abc(%rip), %rdi     # 0x1c7a8
movl $0x44, %esi
callq 0x5050
movq %rax, 0x16ac3(%rip)     # 0x1c7c0
movq 0x16aa4(%rip), %rdi     # 0x1c7a8
movl $0x5c, %esi
callq 0x5050
movq %rax, 0x16ab3(%rip)     # 0x1c7c8
movq 0x16a8c(%rip), %rdi     # 0x1c7a8
movl $0xe, %esi
callq 0x5050
movq %rax, 0x16aa3(%rip)     # 0x1c7d0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x16a6a(%rip), %rcx     # 0x1c7a8
cmpl 0xe4(%rcx), %eax
jge 0x5da5
movl $0x1, %edi
movl $0x2f0, %esi            # imm = 0x2F0
callq 0x6460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5e70
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq 0x13701(%rip), %rcx     # 0x19478
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq 0x136ee(%rip), %rax     # 0x19478
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x136e0(%rip)     # 0x19478
jmp 0x5d9a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d34
movq 0x14914(%rip), %rax     # 0x1a6c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5dd4
movq -0x10(%rbp), %rsi
leaq 0x148fe(%rip), %rdi     # 0x1a6c0
callq 0xc840
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5db0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: x_teardown
static void
x_teardown(void)
{
	struct screen_ctx	*sc;

	TAILQ_FOREACH(sc, &Screenq, entry)
		XFreeGC(X_Dpy, sc->gc);

	XCloseDisplay(X_Dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13681(%rip), %rax     # 0x19470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e1e
movq 0x169a7(%rip), %rdi     # 0x1c7a8
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x5410
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5df3
movq 0x16983(%rip), %rdi     # 0x1c7a8
callq 0x5350
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/screen.c
// Function: screen_fromroot
struct screen_ctx *
screen_fromroot(Window rootwin)
{
	struct screen_ctx	*sc;

	TAILQ_FOREACH(sc, &Screenq, entry)
		if (sc->rootwin == rootwin)
			return (sc);

	/* XXX FAIL HERE */
	return (TAILQ_FIRST(&Screenq));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x13401(%rip), %rax     # 0x19470
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x60a4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6095
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60b2
jmp 0x6097
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6076
leaq 0x133c5(%rip), %rax     # 0x19470
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/screen.c
// Function: screen_updatestackingorder
void
screen_updatestackingorder(struct screen_ctx *sc)
{
	Window			*wins, w0, w1;
	struct client_ctx	*cc;
	u_int			 nwins, i, s;

	if (!XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins))
		return;

	for (s = 0, i = 0; i < nwins; i++) {
		/* Skip hidden windows */
		if ((cc = client_find(wins[i])) == NULL ||
		    cc->flags & CLIENT_HIDDEN)
			continue;

		cc->stackingorder = s++;
	}

	XFree(wins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x166d5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x10(%rbp), %r8
leaq -0x2c(%rbp), %r9
callq 0x5850
cmpl $0x0, %eax
jne 0x60fa
jmp 0x6167
movl $0x0, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x615e
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x6510
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x613c
movq -0x28(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x613e
jmp 0x6153
movl -0x34(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl %ecx, 0xb4(%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6108
movq -0x10(%rbp), %rdi
callq 0x5060
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/screen.c
// Function: screen_find_xinerama
XineramaScreenInfo *
screen_find_xinerama(struct screen_ctx *sc, int x, int y)
{
	XineramaScreenInfo	*info;
	int			 i;

	if (sc->xinerama == NULL)
		return (NULL);

	for (i = 0; i < sc->xinerama_no; i++) {
		info = &sc->xinerama[i];
		if (x >= info->x_org && x < info->x_org + info->width &&
		    y >= info->y_org && y < info->y_org + info->height)
			return (info);
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x6199
movq $0x0, -0x8(%rbp)
jmp 0x623f
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x108(%rcx), %eax
jge 0x6237
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movswl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jl 0x6227
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movswl 0x4(%rcx), %ecx
movq -0x20(%rbp), %rdx
movswl 0x8(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x6227
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movswl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jl 0x6227
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movswl 0x6(%rcx), %ecx
movq -0x20(%rbp), %rdx
movswl 0xa(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x6227
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x623f
jmp 0x6229
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x61a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/screen.c
// Function: screen_update_geometry
void
screen_update_geometry(struct screen_ctx *sc)
{
	sc->view.x = 0;
	sc->view.y = 0;
	sc->view.w = DisplayWidth(X_Dpy, sc->which);
	sc->view.h = DisplayHeight(X_Dpy, sc->which);

	sc->work.x = sc->view.x + sc->gap.left;
	sc->work.y = sc->view.y + sc->gap.top;
	sc->work.w = sc->view.w - (sc->gap.left + sc->gap.right);
	sc->work.h = sc->view.h - (sc->gap.top + sc->gap.bottom);

	screen_init_xinerama(sc);

	xu_ewmh_net_desktop_geometry(sc);
	xu_ewmh_net_workarea(sc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xa4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa8(%rax)
leaq 0x16529(%rip), %rax     # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xac(%rax)
leaq 0x164fd(%rip), %rax     # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0xcc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0xc4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %eax
movq -0x8(%rbp), %rdx
addl 0xd0(%rdx), %eax
subl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl 0xb0(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %eax
movq -0x8(%rbp), %rdx
addl 0xc8(%rdx), %eax
subl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x8(%rbp), %rdi
callq 0x6390
movq -0x8(%rbp), %rdi
callq 0xb4c0
movq -0x8(%rbp), %rdi
callq 0xb530
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/screen.c
// Function: screen_init_xinerama
void
screen_init_xinerama(struct screen_ctx *sc)
{
	XineramaScreenInfo	*info = NULL;
	int			 no = 0;

	if (XineramaIsActive(X_Dpy))
		info = XineramaQueryScreens(X_Dpy, &no);

	if (sc->xinerama != NULL)
		XFree(sc->xinerama);
	sc->xinerama = info;
	sc->xinerama_no = no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x163f6(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
callq 0x5650
cmpl $0x0, %eax
je 0x63d6
leaq 0x163e2(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5040
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0x63f4
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0x5060
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_find
struct client_ctx *
client_find(Window win)
{
	struct client_ctx	*cc;

	TAILQ_FOREACH(cc, &Clientq, entry)
		if (cc->win == win)
			return (cc);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x12f61(%rip), %rax     # 0x19480
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6554
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6545
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x655c
jmp 0x6547
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6526
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_draw_border
void
client_draw_border(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	unsigned long		 pixel;

	if (cc->active)
		switch (cc->highlight) {
		case CLIENT_HIGHLIGHT_GROUP:
			pixel = sc->color[CWM_COLOR_BORDER_GROUP].pixel;
			break;
		case CLIENT_HIGHLIGHT_UNGROUP:
			pixel = sc->color[CWM_COLOR_BORDER_UNGROUP].pixel;
			break;
		default:
			pixel = sc->color[CWM_COLOR_BORDER_ACTIVE].pixel;
			break;
		}
	else
		pixel = sc->color[CWM_COLOR_BORDER_INACTIVE].pixel;

	XSetWindowBorderWidth(X_Dpy, cc->win, cc->bwidth);
	XSetWindowBorder(X_Dpy, cc->win, pixel);
}

// 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 -0x8(%rbp), %rax
cmpl $0x0, 0xb0(%rax)
je 0x727d
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x7253
jmp 0x7249
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x7261
jmp 0x726f
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x727b
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x727b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7289
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x15518(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edx
callq 0x5660
leaq 0x154fa(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x5330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_transient
void
client_transient(struct client_ctx *cc)
{
	struct client_ctx	*tc;
	Window			 trans;

	if (XGetTransientForHint(X_Dpy, cc->win, &trans)) {
		if ((tc = client_find(trans)) && tc->group) {
			group_movetogroup(cc, tc->group->shortcut - 1);
			if (tc->flags & CLIENT_IGNORE)
				cc->flags |= CLIENT_IGNORE;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x154c5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0x57b0
cmpl $0x0, %eax
je 0x7360
movq -0x18(%rbp), %rdi
callq 0x6510
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x735e
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x735e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movl 0x20(%rax), %esi
subl $0x1, %esi
callq 0xdbd0
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x735c
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xa8(%rax)
jmp 0x735e
jmp 0x7360
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_hide
void
client_hide(struct client_ctx *cc)
{
	/* XXX - add wm_state stuff */
	XUnmapWindow(X_Dpy, cc->win);

	cc->active = 0;
	cc->flags |= CLIENT_HIDDEN;
	xu_setstate(cc, IconicState);

	if (cc == _curcc)
		client_none(cc->sc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x15425(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x53c0
movq -0x8(%rbp), %rax
movl $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xb1c0
movq -0x8(%rbp), %rax
cmpq 0x15413(%rip), %rax     # 0x1c7e0
jne 0x73dc
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x77d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_unhide
void
client_unhide(struct client_ctx *cc)
{
	XMapRaised(X_Dpy, cc->win);

	cc->highlight = 0;
	cc->flags &= ~CLIENT_HIDDEN;
	xu_setstate(cc, NormalState);
	client_draw_border(cc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x153a5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x5800
movq -0x8(%rbp), %rax
movl $0x0, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xb1c0
movq -0x8(%rbp), %rdi
callq 0x7210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_gethints
static void
client_gethints(struct client_ctx *cc)
{
	XClassHint		 xch;
	struct mwm_hints	*mwmh;

	if (XGetClassHint(X_Dpy, cc->win, &xch)) {
		if (xch.res_name != NULL)
			cc->app_name = xch.res_name;
		if (xch.res_class != NULL)
			cc->app_class = xch.res_class;
	}

	if (xu_getprop(cc->win, cwmh[_MOTIF_WM_HINTS].atom, _MOTIF_WM_HINTS,
	    PROP_MWM_HINTS_ELEMENTS, (u_char **)&mwmh) == MWM_NUMHINTS)
		if (mwmh->flags & MWM_HINTS_DECORATIONS &&
		    !(mwmh->decorations & MWM_DECOR_ALL) &&
		    !(mwmh->decorations & MWM_DECOR_BORDER))
			cc->bwidth = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x15335(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0x53d0
cmpl $0x0, %eax
je 0x74ba
cmpq $0x0, -0x18(%rbp)
je 0x74a2
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x74b8
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xf8(%rax)
jmp 0x74ba
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x11fd7(%rip), %rax     # 0x194a0
movq 0x48(%rax), %rsi
movl $0x4, %edx
movl $0x3, %ecx
leaq -0x20(%rbp), %r8
callq 0xaf70
cmpl $0x3, %eax
jne 0x7527
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x7525
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x7525
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
jne 0x7525
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
jmp 0x7527
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_update
static void
client_update(struct client_ctx *cc)
{
	Atom	*p;
	int	 i;
	long	 n;

	if ((n = xu_getprop(cc->win, cwmh[WM_PROTOCOLS].atom,
		 XA_ATOM, 20L, (u_char **)&p)) <= 0)
		return;

	for (i = 0; i < n; i++)
		if (p[i] == cwmh[WM_DELETE_WINDOW].atom)
			cc->xproto |= CLIENT_PROTO_DELETE;
		else if (p[i] == cwmh[WM_TAKE_FOCUS].atom)
			cc->xproto |= CLIENT_PROTO_TAKEFOCUS;

	XFree(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x11f55(%rip), %rax     # 0x194a0
movq 0x38(%rax), %rsi
movl $0x4, %edx
movl $0x14, %ecx
leaq -0x10(%rbp), %r8
callq 0xaf70
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jg 0x7573
jmp 0x75f6
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x75ed
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x11f09(%rip), %rcx     # 0x194a0
cmpq 0x18(%rcx), %rax
jne 0x75b2
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xa4(%rax)
jmp 0x75e0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x11edb(%rip), %rcx     # 0x194a0
cmpq 0x28(%rcx), %rax
jne 0x75de
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xa4(%rax)
jmp 0x75e0
jmp 0x75e2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x757a
movq -0x10(%rbp), %rdi
callq 0x5060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_delete
void
client_delete(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	struct winname		*wn;

	group_client_delete(cc);

	XGrabServer(X_Dpy);
	xu_setstate(cc, WithdrawnState);
	XRemoveFromSaveSet(X_Dpy, cc->win);

	XSync(X_Dpy, False);
	XUngrabServer(X_Dpy);

	TAILQ_REMOVE(&sc->mruq, cc, mru_entry);
	TAILQ_REMOVE(&Clientq, cc, entry);

	xu_ewmh_net_client_list(sc);

	if (_curcc == cc)
		client_none(sc);

	XFree(cc->size);

	while ((wn = TAILQ_FIRST(&cc->nameq)) != NULL) {
		TAILQ_REMOVE(&cc->nameq, wn, entry);
		if (wn->name != emptystring)
			xfree(wn->name);
		xfree(wn);
	}

	client_freehints(cc);
	xfree(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 -0x8(%rbp), %rdi
callq 0xe440
leaq 0x15180(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
callq 0x5120
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xb1c0
leaq 0x15166(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x5290
leaq 0x1514f(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x55b0
leaq 0x1513e(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
callq 0x5420
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7693
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x76a6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
jmp 0x76bb
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x76da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x76ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x11d97(%rip), %rax     # 0x19480
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xb650
movq 0x150d1(%rip), %rax     # 0x1c7e0
cmpq -0x8(%rbp), %rax
jne 0x771e
movq -0x10(%rbp), %rdi
callq 0x77d0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x5060
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x77b2
jmp 0x7742
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7761
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x7774
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x15057(%rip), %rcx     # 0x1c7e8
cmpq %rcx, 0x10(%rax)
je 0x77a4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x64b0
movq -0x18(%rbp), %rdi
callq 0x64b0
jmp 0x772b
movq -0x8(%rbp), %rdi
callq 0x7810
movq -0x8(%rbp), %rdi
callq 0x64b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_freehints
static void
client_freehints(struct client_ctx *cc)
{
	if (cc->app_name != NULL)
		XFree(cc->app_name);
	if (cc->app_class != NULL)
		XFree(cc->app_class);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0x783a
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x5060
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0x7858
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rdi
callq 0x5060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_leave
void
client_leave(struct client_ctx *cc)
{
	struct screen_ctx	*sc;

	if (cc == NULL)
		cc = _curcc;
	if (cc == NULL)
		return;

	sc = cc->sc;
	xu_btn_ungrab(sc->rootwin, AnyModifier, Button1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x787e
movq 0x14f66(%rip), %rax     # 0x1c7e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7887
jmp 0x78aa
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x8000, %esi           # imm = 0x8000
movl $0x1, %edx
callq 0xab90
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_setactive
void
client_setactive(struct client_ctx *cc, int fg)
{
	struct screen_ctx	*sc;

	if (cc == NULL)
		cc = _curcc;
	if (cc == NULL)
		return;

	sc = cc->sc;

	if (fg) {
		XInstallColormap(X_Dpy, cc->cmap);
		XSetInputFocus(X_Dpy, cc->win,
		    RevertToPointerRoot, CurrentTime);
		conf_grab_mouse(cc);
		/*
		 * If we're in the middle of alt-tabbing, don't change
		 * the order please.
		 */
		if (!sc->cycling)
			client_mtf(cc);
	} else
		client_leave(cc);

	if (fg && _curcc != cc) {
		client_setactive(NULL, 0);
		_curcc = cc;
		xu_ewmh_net_active_window(sc, cc->win);
	}

	cc->active = fg;
	client_draw_border(cc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x78d1
movq 0x14f13(%rip), %rax     # 0x1c7e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x78dd
jmp 0x79a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x7947
leaq 0x14eb2(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x5640
leaq 0x14e9b(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x5570
movq -0x8(%rbp), %rdi
callq 0xcac0
movq -0x18(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
jne 0x7945
movq -0x8(%rbp), %rdi
callq 0x79b0
jmp 0x7950
movq -0x8(%rbp), %rdi
callq 0x7860
cmpl $0x0, -0xc(%rbp)
je 0x798a
movq 0x14e83(%rip), %rax     # 0x1c7e0
cmpq -0x8(%rbp), %rax
je 0x798a
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x78b0
movq -0x8(%rbp), %rax
movq %rax, 0x14e67(%rip)     # 0x1c7e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xb740
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x8(%rbp), %rdi
callq 0x7210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_mtf
void
client_mtf(struct client_ctx *cc)
{
	struct screen_ctx	*sc;

	if (cc == NULL)
		cc = _curcc;
	if (cc == NULL)
		return;

	sc = cc->sc;

	/* Move to front. */
	TAILQ_REMOVE(&sc->mruq, cc, mru_entry);
	TAILQ_INSERT_HEAD(&sc->mruq, cc, mru_entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x79ca
movq 0x14e1a(%rip), %rax     # 0x1c7e0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x79d6
jmp 0x7a92
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7a03
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x7a16
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
jmp 0x7a2b
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
je 0x7a5d
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x7a70
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rcx
addq $0xd8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_resize
void
client_resize(struct client_ctx *cc, int reset)
{
	if (reset) {
		cc->flags &= ~CLIENT_MAXIMIZED;
		cc->bwidth = Conf.bwidth;
	}

	client_draw_border(cc);

	XMoveResizeWindow(X_Dpy, cc->win, cc->geom.x,
	    cc->geom.y, cc->geom.w, cc->geom.h);
	xu_configure(cc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x7d59
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
andl $-0xd, %ecx
movl %ecx, 0xa8(%rax)
leaq 0x12971(%rip), %rax     # 0x1a6c0
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x7210
leaq 0x14a3f(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x54(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x60(%rax), %r9d
callq 0x5440
movq -0x8(%rbp), %rdi
callq 0xae30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_ptrwarp
void
client_ptrwarp(struct client_ctx *cc)
{
	int	 x = cc->ptr.x, y = cc->ptr.y;

	if (x == -1 || y == -1) {
		x = cc->geom.w / 2;
		y = cc->geom.h / 2;
	}

	(cc->state == IconicState) ? client_unhide(cc) : client_raise(cc);
	xu_ptr_setpos(cc->win, x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xa0(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x8202
cmpl $-0x1, -0x10(%rbp)
jne 0x8226
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0xac(%rax)
jne 0x823e
movq -0x8(%rbp), %rdi
callq 0x73f0
jmp 0x8247
movq -0x8(%rbp), %rdi
callq 0x81a0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xac50
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_ptrsave
void
client_ptrsave(struct client_ctx *cc)
{
	int	 x, y;

	xu_ptr_getpos(cc->win, &x, &y);
	if (client_inbound(cc, x, y)) {
		cc->ptr.x = x;
		cc->ptr.y = y;
	} else {
		cc->ptr.x = -1;
		cc->ptr.y = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xabf0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x82e0
cmpl $0x0, %eax
je 0x82b1
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xa0(%rax)
jmp 0x82cd
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x9c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_send_delete
void
client_send_delete(struct client_ctx *cc)
{
	if (cc->xproto & CLIENT_PROTO_DELETE)
		xu_sendmsg(cc->win,
		    cwmh[WM_PROTOCOLS].atom, cwmh[WM_DELETE_WINDOW].atom);
	else
		XKillClient(X_Dpy, cc->win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8373
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x11143(%rip), %rax     # 0x194a0
movq 0x38(%rax), %rsi
leaq 0x11138(%rip), %rax     # 0x194a0
movq 0x18(%rax), %rdx
callq 0xaed0
jmp 0x838a
leaq 0x1442e(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x5890
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_cycle
void
client_cycle(struct screen_ctx *sc, int flags)
{
	struct client_ctx	*oldcc, *newcc;
	int			 again = 1;

	oldcc = client_current();

	/* If no windows then you cant cycle */
	if (TAILQ_EMPTY(&sc->mruq))
		return;

	if (oldcc == NULL)
		oldcc = (flags & CWM_RCYCLE ? 
		    TAILQ_LAST(&sc->mruq, cycle_entry_q) :
		    TAILQ_FIRST(&sc->mruq));

	newcc = oldcc;
	while (again) {
		again = 0;

		newcc = (flags & CWM_RCYCLE ? client_mruprev(newcc) :
		    client_mrunext(newcc));

		/* Only cycle visible and non-ignored windows. */
		if ((newcc->flags & (CLIENT_HIDDEN|CLIENT_IGNORE))
			|| ((flags & CWM_INGROUP) && (newcc->group != oldcc->group)))
			again = 1;

		/* Is oldcc the only non-hidden window? */
		if (newcc == oldcc) {
			if (again)
				return;	/* No windows visible. */

			break;
		}
	}

	/* reset when cycling mod is released. XXX I hate this hack */
	sc->cycling = 1;
	client_ptrsave(oldcc);
	client_ptrwarp(newcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x24(%rbp)
callq 0x7aa0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x83c2
jmp 0x84c0
cmpq $0x0, -0x18(%rbp)
jne 0x8403
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x83ec
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x83fb
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x84a0
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8436
movq -0x20(%rbp), %rdi
callq 0x84d0
movq %rax, -0x38(%rbp)
jmp 0x8443
movq -0x20(%rbp), %rdi
callq 0x8530
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x8480
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8487
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
je 0x8487
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x849b
cmpl $0x0, -0x24(%rbp)
je 0x8499
jmp 0x84c0
jmp 0x84a0
jmp 0x840b
movq -0x8(%rbp), %rax
movl $0x1, 0xa0(%rax)
movq -0x18(%rbp), %rdi
callq 0x8260
movq -0x20(%rbp), %rdi
callq 0x81d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_mruprev
static struct client_ctx *
client_mruprev(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	struct client_ctx	*ccc;

	return ((ccc = TAILQ_PREV(cc, cycle_entry_q, mru_entry)) != NULL ?
	    ccc : TAILQ_LAST(&sc->mruq, cycle_entry_q));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8507
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x851d
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_mrunext
static struct client_ctx *
client_mrunext(struct client_ctx *cc)
{
	struct screen_ctx	*sc = cc->sc;
	struct client_ctx	*ccc;

	return ((ccc = TAILQ_NEXT(cc, mru_entry)) != NULL ?
	    ccc : TAILQ_FIRST(&sc->mruq));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8560
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x856f
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_cycle_leave
void
client_cycle_leave(struct screen_ctx *sc, struct client_ctx *cc) 
{
	sc->cycling = 0;

	client_mtf(NULL);
	if (cc) {
		group_sticky_toggle_exit(cc);
		XUngrabKeyboard(X_Dpy, CurrentTime);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xa0(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x79b0
cmpq $0x0, -0x10(%rbp)
je 0x85ca
movq -0x10(%rbp), %rdi
callq 0xde90
leaq 0x141ea(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/client.c
// Function: client_snapcalc
int
client_snapcalc(int n, int dn, int nmax, int bwidth, int snapdist)
{
	int	 n0, n1, s0, s1;

	s0 = s1 = 0;
	n0 = n;
	n1 = n + dn + (bwidth * 2);

	if (abs(n0) <= snapdist)
		s0 = -n0;

	if (nmax - snapdist <= n1 && n1 <= nmax + snapdist)
		s1 = nmax - n1;

	/* possible to snap in both directions */
	if (s0 != 0 && s1 != 0)
		if (abs(s0) < abs(s1))
			return (s0);
		else
			return (s1);
	else if (s0 != 0)
		return (s0);
	else if (s1 != 0)
		return (s1);
	else
		return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x18(%rbp), %eax
jg 0x88cf
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x88f0
movl -0x20(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x88f0
movl -0x10(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x8924
cmpl $0x0, -0x28(%rbp)
je 0x8924
movl -0x24(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl -0x28(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x891c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8947
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8947
cmpl $0x0, -0x24(%rbp)
je 0x8932
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8947
cmpl $0x0, -0x28(%rbp)
je 0x8940
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8947
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/menu.c
// Function: menu_init
void
menu_init(struct screen_ctx *sc)
{
	XGCValues	 gv;

	sc->menuwin = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0, 1, 1,
	    Conf.bwidth,
	    sc->color[CWM_COLOR_FG_MENU].pixel,
	    sc->color[CWM_COLOR_BG_MENU].pixel);

	gv.foreground =
	    sc->color[CWM_COLOR_FG_MENU].pixel^sc->color[CWM_COLOR_BG_MENU].pixel;
	gv.background = sc->color[CWM_COLOR_BG_MENU].pixel;
	gv.function = GXxor;

	sc->gc = XCreateGC(X_Dpy, sc->menuwin,
	    GCForeground|GCBackground|GCFunction, &gv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x13e42(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x11d48(%rip), %rax     # 0x1a6c0
movl 0x54(%rax), %r11d
movq -0x8(%rbp), %rax
movq 0x70(%rax), %r10
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
xorl %ecx, %ecx
movl $0x1, %r9d
movl %ecx, %edx
movl %r9d, %r8d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5280
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
xorq 0x80(%rcx), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x6, -0x88(%rbp)
leaq 0x13db7(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0xd, %edx
leaq -0x88(%rbp), %rcx
callq 0x5540
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/menu.c
// Function: menu_handle_move
static void
menu_handle_move(XEvent *e, struct menu_ctx *mc, struct screen_ctx *sc)
{
	mc->prev = mc->entry;
	mc->entry = menu_calc_entry(sc, mc, e->xbutton.x, e->xbutton.y);

	if (mc->prev != -1)
		XFillRectangle(X_Dpy, sc->menuwin, sc->gc, 0,
		    font_height(sc) * mc->prev, mc->width, font_height(sc));
	if (mc->entry != -1) {
		(void)xu_ptr_regrab(MENUGRABMASK, Cursor_normal);
		XFillRectangle(X_Dpy, sc->menuwin, sc->gc, 0,
		    font_height(sc) * mc->entry, mc->width, font_height(sc));
	} else
		(void)xu_ptr_regrab(MENUGRABMASK, Cursor_default);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xe4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe0(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
callq 0xa000
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xe0(%rax)
je 0x9c90
leaq 0x12b85(%rip), %rax     # 0x1c7a8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x109b0
movq -0x10(%rbp), %rcx
imull 0xe0(%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x109b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x20(%rbp), %r8d
movl -0x1c(%rbp), %r9d
xorl %ecx, %ecx
movl %eax, (%rsp)
callq 0x53a0
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xe4(%rax)
je 0x9d2b
leaq 0x12b18(%rip), %rax     # 0x1c7c0
movq (%rax), %rsi
movl $0x2204c, %edi          # imm = 0x2204C
callq 0xaaa0
leaq 0x12aec(%rip), %rax     # 0x1c7a8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x109b0
movq -0x10(%rbp), %rcx
imull 0xe4(%rcx), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x109b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %r8d
movl -0x3c(%rbp), %r9d
xorl %ecx, %ecx
movl %eax, (%rsp)
callq 0x53a0
jmp 0x9d3f
leaq 0x12a7e(%rip), %rax     # 0x1c7b0
movq (%rax), %rsi
movl $0x2204c, %edi          # imm = 0x2204C
callq 0xaaa0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/menu.c
// Function: menu_handle_release
static struct menu *
menu_handle_release(XEvent *e, struct menu_ctx *mc, struct screen_ctx *sc,
    struct menu_q *resultq)
{
	struct menu	*mi;
	int		 entry, i = 0;

	entry = menu_calc_entry(sc, mc, e->xbutton.x, e->xbutton.y);

	if (mc->hasprompt)
		i = 1;

	TAILQ_FOREACH(mi, resultq, resultentry)
		if (entry == i++)
			break;
	if (mi == NULL) {
		mi = xmalloc(sizeof(*mi));
		mi->text[0] = '\0';
		mi->dummy = 1;
	}
	return (mi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
callq 0xa000
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xcc(%rax)
je 0x9da1
movl $0x1, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9dd7
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
cmpl %ecx, %eax
jne 0x9dc7
jmp 0x9dd7
jmp 0x9dc9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9dac
cmpq $0x0, -0x28(%rbp)
jne 0x9e01
movl $0x98, %edi
callq 0x6420
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movw $0x1, 0x90(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/menu.c
// Function: menu_calc_entry
static int
menu_calc_entry(struct screen_ctx *sc, struct menu_ctx *mc, int x, int y)
{
	int	 entry;

	entry = y / font_height(sc);

	/* in bounds? */
	if (x <= 0 || x > mc->width || y <= 0 ||
	    y > font_height(sc) * mc->num || entry < 0 || entry >= mc->num)
		entry = -1;

	if (mc->hasprompt && entry == 0)
		entry = -1;

	return (entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x109b0
movl %eax, %ecx
movl -0x20(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xa084
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xec(%rcx), %eax
jg 0xa084
cmpl $0x0, -0x18(%rbp)
jle 0xa084
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x109b0
movl %eax, %ecx
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rdx
imull 0xf0(%rdx), %ecx
cmpl %ecx, %eax
ja 0xa084
cmpl $0x0, -0x1c(%rbp)
jl 0xa084
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xf0(%rcx), %eax
jl 0xa08b
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpl $0x0, 0xcc(%rax)
je 0xa0a5
cmpl $0x0, -0x1c(%rbp)
jne 0xa0a5
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/search.c
// Function: strsubmatch
static int
strsubmatch(char *sub, char *str, int zeroidx)
{
	size_t	 len, sublen;
	u_int	 n, flen;

	if (sub == NULL || str == NULL)
		return (0);

	len = strlen(str);
	sublen = strlen(sub);

	if (sublen > len)
		return (0);

	if (!zeroidx)
		flen = len - sublen;
	else
		flen = 0;

	for (n = 0; n <= flen; n++)
		if (strncasecmp(sub, str + n, sublen) == 0)
			return (1);

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa3e1
cmpq $0x0, -0x18(%rbp)
jne 0xa3ed
movl $0x0, -0x4(%rbp)
jmp 0xa47c
movq -0x18(%rbp), %rdi
callq 0x5320
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5320
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xa41a
movl $0x0, -0x4(%rbp)
jmp 0xa47c
cmpl $0x0, -0x1c(%rbp)
jne 0xa42d
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movl %eax, -0x38(%rbp)
jmp 0xa434
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
ja 0xa475
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %eax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x55d0
cmpl $0x0, %eax
jne 0xa468
movl $0x1, -0x4(%rbp)
jmp 0xa47c
jmp 0xa46a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa43b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/search.c
// Function: search_print_client
void
search_print_client(struct menu *mi, int list)
{
	struct client_ctx	*cc;
	char			 flag = ' ';

	cc = mi->ctx;

	if (cc == client_current())
		flag = '!';
	else if (cc->flags & CLIENT_HIDDEN)
		flag = '&';

	if (list)
		cc->matchname = cc->name;

	(void)snprintf(mi->print, sizeof(mi->print), "%c%s", flag,
	    cc->matchname);

	if (!list && cc->matchname != cc->name &&
	    strlen(mi->print) < sizeof(mi->print) - 1) {
		const char	*marker = "";
		char		 buf[MENU_MAXENTRY + 1];
		int		 diff;

		diff = sizeof(mi->print) - 1 - strlen(mi->print);

		/* One for the ':' */
		diff -= 1;

		if (strlen(cc->name) > diff) {
			marker = "..";
			diff -= 2;
		} else {
			diff = strlen(cc->name);
		}

		(void)strlcpy(buf, mi->print, sizeof(buf));
		(void)snprintf(mi->print, sizeof(mi->print),
		    "%s:%.*s%s", buf, diff, cc->name, marker);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x20, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x7aa0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jne 0xa4d4
movb $0x21, -0x19(%rbp)
jmp 0xa4ec
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa4ea
movb $0x26, -0x19(%rbp)
jmp 0xa4ec
cmpl $0x0, -0xc(%rbp)
je 0xa508
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rdi
addq $0x53, %rdi
movsbl -0x19(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %r8
movl $0x33, %esi
leaq 0x9dd3(%rip), %rdx      # 0x142fe
movb $0x0, %al
callq 0x50b0
cmpl $0x0, -0xc(%rbp)
jne 0xa62c
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0xd8(%rcx), %rax
je 0xa62c
movq -0x8(%rbp), %rdi
addq $0x53, %rdi
callq 0x5320
cmpq $0x32, %rax
jae 0xa62c
leaq 0x9da1(%rip), %rax      # 0x14317
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x53, %rdi
callq 0x5320
movq %rax, %rcx
movl $0x32, %eax
subq %rcx, %rax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x5320
movslq -0x64(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xa5cd
leaq 0x9d45(%rip), %rax      # 0x14303
movq %rax, -0x28(%rbp)
movl -0x64(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x64(%rbp)
jmp 0xa5e0
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x5320
movl %eax, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x53, %rsi
movl $0x33, %edx
callq 0x12ce0
movq -0x8(%rbp), %rdi
addq $0x53, %rdi
leaq -0x60(%rbp), %rcx
movl -0x64(%rbp), %r8d
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %r9
movq -0x28(%rbp), %rax
movl $0x33, %esi
leaq 0x9ce5(%rip), %rdx      # 0x14306
movq %rax, (%rsp)
movb $0x0, %al
callq 0x50b0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)