LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/search.c
// Function: search_match_text
void
search_match_text(struct menu_q *menuq, struct menu_q *resultq, char *search)
{
	struct menu	*mi;

	TAILQ_INIT(resultq);

	TAILQ_FOREACH(mi, menuq, entry)
		if (strsubmatch(search, mi->text, 0))
			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa6e3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
xorl %edx, %edx
callq 0xa3c0
cmpl $0x0, %eax
je 0xa6d4
jmp 0xa697
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa6d4
jmp 0xa6d6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa676
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/search.c
// Function: search_match_exec
void
search_match_exec(struct menu_q *menuq, struct menu_q *resultq, char *search)
{
	struct menu	*mi, *mj;

	TAILQ_INIT(resultq);

	TAILQ_FOREACH(mi, menuq, entry) {
		if (strsubmatch(search, mi->text, 1) == 0 &&
		    fnmatch(search, mi->text, 0) == FNM_NOMATCH)
				continue;
		for (mj = TAILQ_FIRST(resultq); mj != NULL;
		     mj = TAILQ_NEXT(mj, resultentry)) {
			if (strcasecmp(mi->text, mj->text) < 0) {
				TAILQ_INSERT_BEFORE(mj, mi, resultentry);
				break;
			}
		}
		if (mj == NULL)
			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa83c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
movl $0x1, %edx
callq 0xa3c0
cmpl $0x0, %eax
jne 0xa769
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
xorl %edx, %edx
callq 0x5300
cmpl $0x1, %eax
jne 0xa769
jmp 0xa82c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa7e4
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
callq 0x51a0
cmpl $0x0, %eax
jge 0xa7d4
jmp 0xa797
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xa7e4
jmp 0xa7d6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa774
cmpq $0x0, -0x28(%rbp)
jne 0xa82a
jmp 0xa7ed
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa82a
jmp 0xa82c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa726
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/util.c
// Function: u_spawn
void
u_spawn(char *argstr)
{
	switch (fork()) {
	case 0:
		u_exec(argstr);
		err(1, "%s", argstr);
		break;
	case -1:
		warn("fork");
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x57a0
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
subl $-0x1, %eax
je 0xa896
jmp 0xa86d
movl -0xc(%rbp), %eax
testl %eax, %eax
jne 0xa8a4
jmp 0xa876
movq -0x8(%rbp), %rdi
callq 0xa8b0
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0xa19d(%rip), %rsi      # 0x14a2c
movb $0x0, %al
callq 0x54b0
leaq 0x9a73(%rip), %rdi      # 0x14310
movb $0x0, %al
callq 0x5870
jmp 0xa8a6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/util.c
// Function: u_exec
void
u_exec(char *argstr)
{
	char	*args[MAXARGLEN], **ap = args;
	char	**end = &args[MAXARGLEN - 1], *tmp;

	while (ap < end && (*ap = strsep(&argstr, " \t")) != NULL) {
		if (**ap == '\0')
			continue;
		ap++;
		if (argstr != NULL) {
			/* deal with quoted strings */
			switch(argstr[0]) {
			case '"':
			case '\'':
				if ((tmp = strchr(argstr + 1, argstr[0]))
				    != NULL) {
					*(tmp++) = '\0';
					*(ap++) = ++argstr;
					argstr = tmp;
				}
				break;
			default:
				break;
			}
		}
	}

	*ap = NULL;
	(void)setsid();
	(void)execvp(args[0], args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rax
addq $0x98, %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rcx
xorl %eax, %eax
cmpq -0xc0(%rbp), %rcx
movb %al, -0xc9(%rbp)
jae 0xa920
leaq -0x8(%rbp), %rdi
leaq 0x9a11(%rip), %rsi      # 0x14315
callq 0x5780
movq -0xb8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
setne %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0xa92f
jmp 0xa9f4
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa943
jmp 0xa8e1
movq -0xb8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa9ef
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xd0(%rbp)
subl $0x22, %eax
je 0xa981
jmp 0xa974
movl -0xd0(%rbp), %eax
subl $0x27, %eax
jne 0xa9eb
jmp 0xa981
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
callq 0x5520
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0xa9e9
movq -0xc8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xc8(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0xb8(%rbp)
movq %rcx, (%rax)
movq -0xc8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa9ed
jmp 0xa9ed
jmp 0xa9ef
jmp 0xa8e1
movq -0xb8(%rbp), %rax
movq $0x0, (%rax)
callq 0x50c0
movq -0xb0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x5170
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_key_grab
void
xu_key_grab(Window win, int mask, int keysym)
{
	KeyCode	 code;
	int	 i;

	code = XKeysymToKeycode(X_Dpy, keysym);
	if ((XkbKeycodeToKeysym(X_Dpy, code, 0, 0) != keysym) &&
	    (XkbKeycodeToKeysym(X_Dpy, code, 0, 1) == keysym))
		mask |= ShiftMask;

	for (i = 0; i < nitems(ign_mods); i++)
		XGrabKey(X_Dpy, code, (mask | ign_mods[i]), win,
		    True, GrabModeAsync, GrabModeAsync);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x11aef(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x56e0
movb %al, -0x11(%rbp)
leaq 0x11ad9(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %ecx, %ecx
movzbl -0x11(%rbp), %esi
movl %ecx, %edx
callq 0x5270
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xad14
leaq 0x11ab9(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %edx, %edx
movl $0x1, %ecx
movzbl -0x11(%rbp), %esi
callq 0x5270
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0xad14
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x4, %rax
jae 0xad68
leaq 0x11a7c(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movzbl -0x11(%rbp), %esi
movl -0xc(%rbp), %edx
movslq -0x18(%rbp), %rcx
leaq 0xe74f(%rip), %rax      # 0x19490
orl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x5760
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xad1b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_key_ungrab
void
xu_key_ungrab(Window win, int mask, int keysym)
{
	KeyCode	 code;
	int	 i;

	code = XKeysymToKeycode(X_Dpy, keysym);
	if ((XkbKeycodeToKeysym(X_Dpy, code, 0, 0) != keysym) &&
	    (XkbKeycodeToKeysym(X_Dpy, code, 0, 1) == keysym))
		mask |= ShiftMask;

	for (i = 0; i < nitems(ign_mods); i++)
		XUngrabKey(X_Dpy, code, (mask | ign_mods[i]), win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x11a1f(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x56e0
movb %al, -0x11(%rbp)
leaq 0x11a09(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %ecx, %ecx
movzbl -0x11(%rbp), %esi
movl %ecx, %edx
callq 0x5270
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xade4
leaq 0x119e9(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
xorl %edx, %edx
movl $0x1, %ecx
movzbl -0x11(%rbp), %esi
callq 0x5270
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0xade4
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x4, %rax
jae 0xae28
leaq 0x119ac(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movzbl -0x11(%rbp), %esi
movl -0xc(%rbp), %edx
movslq -0x18(%rbp), %rcx
leaq 0xe67f(%rip), %rax      # 0x19490
orl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rcx
callq 0x5260
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xadeb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_configure
void
xu_configure(struct client_ctx *cc)
{
	XConfigureEvent	 ce;

	ce.type = ConfigureNotify;
	ce.event = cc->win;
	ce.window = cc->win;
	ce.x = cc->geom.x;
	ce.y = cc->geom.y;
	ce.width = cc->geom.w;
	ce.height = cc->geom.h;
	ce.border_width = cc->bwidth;
	ce.above = None;
	ce.override_redirect = 0;

	XSendEvent(X_Dpy, cc->win, False, StructureNotifyMask, (XEvent *)&ce);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x16, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x11905(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x60(%rbp), %r8
callq 0x55e0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_sendmsg
void
xu_sendmsg(Window win, Atom atm, long val)
{
	XEvent	 e;

	(void)memset(&e, 0, sizeof(e));
	e.xclient.type = ClientMessage;
	e.xclient.window = win;
	e.xclient.message_type = atm;
	e.xclient.format = 32;
	e.xclient.data.l[0] = val;
	e.xclient.data.l[1] = CurrentTime;

	XSendEvent(X_Dpy, win, False, 0, &e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xd8(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x5090
movl $0x21, -0xd8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x20, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
leaq 0x11867(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
callq 0x55e0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_getprop
int
xu_getprop(Window win, Atom atm, Atom type, long len, u_char **p)
{
	Atom	 realtype;
	u_long	 n, extra;
	int	 format;

	if (XGetWindowProperty(X_Dpy, win, atm, 0L, len, False, type,
	    &realtype, &format, &n, &extra, p) != Success || *p == NULL)
		return (-1);

	if (n == 0)
		XFree(*p);

	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
leaq 0x1180d(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %r15
movq -0x48(%rbp), %rax
xorl %ecx, %ecx
xorl %r9d, %r9d
leaq -0x50(%rbp), %r14
leaq -0x64(%rbp), %rbx
leaq -0x58(%rbp), %r11
leaq -0x60(%rbp), %r10
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x51e0
cmpl $0x0, %eax
jne 0xaff8
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb001
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xb01b
cmpq $0x0, -0x58(%rbp)
jne 0xb014
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x5060
movq -0x58(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_getstrprop
int
xu_getstrprop(Window win, Atom atm, char **text) {
	XTextProperty	 prop;
	char		**list;
	int		 nitems = 0;

	*text = NULL;

	XGetTextProperty(X_Dpy, win, &prop, atm);
	if (!prop.nitems)
		return (0);

	if (Xutf8TextPropertyToTextList(X_Dpy, &prop, &list,
	    &nitems) == Success && nitems > 0 && *list) {
		if (nitems > 1) {
			XTextProperty    prop2;
			if (Xutf8TextListToTextProperty(X_Dpy, list, nitems,
			    XUTF8StringStyle, &prop2) == Success) {
				*text = xstrdup((const char *)prop2.value);
				XFree(prop2.value);
			}
		} else {
			*text = xstrdup(*list);
		}
		XFreeStringList(list);
	}

	XFree(prop.value);

	return (nitems);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
leaq 0x1174b(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdx
callq 0x5340
cmpq $0x0, -0x28(%rbp)
jne 0xb084
movl $0x0, -0x4(%rbp)
jmp 0xb12a
leaq 0x1171d(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
callq 0x5380
cmpl $0x0, %eax
jne 0xb11b
cmpl $0x0, -0x4c(%rbp)
jle 0xb11b
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb11b
cmpl $0x1, -0x4c(%rbp)
jle 0xb0fc
leaq 0x116e7(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
movl -0x4c(%rbp), %edx
movl $0x4, %ecx
leaq -0x70(%rbp), %r8
callq 0x5480
cmpl $0x0, %eax
jne 0xb0fa
movq -0x70(%rbp), %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rdi
callq 0x5060
jmp 0xb112
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x64d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdi
callq 0x5630
movq -0x40(%rbp), %rdi
callq 0x5060
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_getstate
int
xu_getstate(struct client_ctx *cc, int *state)
{
	long	*p = NULL;

	if (xu_getprop(cc->win, cwmh[WM_STATE].atom, cwmh[WM_STATE].atom, 2L,
	    (u_char **)&p) <= 0)
		return (-1);

	*state = (int)*p;
	XFree((char *)p);

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0xe341(%rip), %rsi      # 0x194a8
movq 0xe33a(%rip), %rdx      # 0x194a8
movl $0x2, %ecx
leaq -0x20(%rbp), %r8
callq 0xaf70
cmpl $0x0, %eax
jg 0xb18a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb1a9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x5060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_setstate
void
xu_setstate(struct client_ctx *cc, int state)
{
	long	 dat[2];

	dat[0] = state;
	dat[1] = None;

	cc->state = state;
	XChangeProperty(X_Dpy, cc->win,
	    cwmh[WM_STATE].atom, cwmh[WM_STATE].atom, 32,
	    PropModeReplace, (unsigned char *)dat, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xac(%rax)
leaq 0x115b5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq 0xe2a3(%rip), %rdx      # 0x194a8
movq 0xe29c(%rip), %rcx      # 0x194a8
leaq -0x20(%rbp), %rax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x5740
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_getatoms
void
xu_getatoms(void)
{
	int	 i;

	for (i = 0; i < nitems(cwmh); i++)
		cwmh[i].atom = XInternAtom(X_Dpy, cwmh[i].name, False);
	for (i = 0; i < nitems(ewmh); i++)
		ewmh[i].atom = XInternAtom(X_Dpy, ewmh[i].name, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x6, %rax
jae 0xb293
leaq 0x11558(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0xe242(%rip), %rax      # 0x194a0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x5690
movq %rax, %rcx
movslq -0x4(%rbp), %rdx
leaq 0xe223(%rip), %rax      # 0x194a0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb23f
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0xe, %rax
jae 0xb2ee
leaq 0x114fd(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0xe247(%rip), %rax      # 0x19500
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x5690
movq %rax, %rcx
movslq -0x4(%rbp), %rdx
leaq 0xe228(%rip), %rax      # 0x19500
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb29a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_supported
void
xu_ewmh_net_supported(struct screen_ctx *sc)
{
	Atom	 atom[EWMH_NITEMS];
	int	 i;

	for (i = 0; i < nitems(ewmh); i++)
		atom[i] = ewmh[i].atom;

	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_SUPPORTED].atom,
	    XA_ATOM, 32, PropModeReplace, (unsigned char *)atom, EWMH_NITEMS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x84(%rbp)
movslq -0x84(%rbp), %rax
cmpq $0xe, %rax
jae 0xb35c
movslq -0x84(%rbp), %rcx
leaq 0xe1cc(%rip), %rax      # 0x19500
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movslq -0x84(%rbp), %rax
movq %rcx, -0x80(%rbp,%rax,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0xb319
leaq 0x11445(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xe193(%rip), %rdx      # 0x19508
leaq -0x80(%rbp), %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0xe, 0x8(%rsp)
callq 0x5740
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_supported_wm_check
void
xu_ewmh_net_supported_wm_check(struct screen_ctx *sc)
{
	Window	 w;

	w = XCreateSimpleWindow(X_Dpy, sc->rootwin, -1, -1, 1, 1, 0, 0, 0);
	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_SUPPORTING_WM_CHECK].atom,
	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
	XChangeProperty(X_Dpy, w, ewmh[_NET_SUPPORTING_WM_CHECK].atom,
	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
	XChangeProperty(X_Dpy, w, ewmh[_NET_WM_NAME].atom,
	    XA_WM_NAME, 8, PropModeReplace, (unsigned char *)WMNAME, strlen(WMNAME));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x113e5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r9d
xorl %eax, %eax
xorl %eax, %eax
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x5280
movq %rax, -0x10(%rbp)
leaq 0x1139d(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xe0fb(%rip), %rdx      # 0x19518
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x10(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x5740
leaq 0x11361(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0xe0c3(%rip), %rdx      # 0x19518
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x10(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x5740
leaq 0x11329(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0xe13b(%rip), %rdx      # 0x195c8
movl $0x27, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
leaq 0x8fd2(%rip), %rax      # 0x14474
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
callq 0x5740
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_workarea
void
xu_ewmh_net_workarea(struct screen_ctx *sc)
{
	long	 workareas[CALMWM_NGROUPS][4];
	int	 i;

	for (i = 0; i < CALMWM_NGROUPS; i++) {
		workareas[i][0] = sc->work.x;
		workareas[i][1] = sc->work.y;
		workareas[i][2] = sc->work.w;
		workareas[i][3] = sc->work.h;
	}

	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_WORKAREA].atom,
	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)workareas,
	    CALMWM_NGROUPS * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movl $0x0, -0x134(%rbp)
cmpl $0x9, -0x134(%rbp)
jge 0xb5f9
movq -0x8(%rbp), %rax
movslq 0xb4(%rax), %rcx
movslq -0x134(%rbp), %rdx
leaq -0x130(%rbp), %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq 0xb8(%rax), %rcx
movslq -0x134(%rbp), %rdx
leaq -0x130(%rbp), %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq 0xbc(%rax), %rcx
movslq -0x134(%rbp), %rdx
leaq -0x130(%rbp), %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq 0xc0(%rax), %rcx
movslq -0x134(%rbp), %rdx
leaq -0x130(%rbp), %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0xb549
leaq 0x111a8(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xdfa6(%rip), %rdx      # 0x195b8
leaq -0x130(%rbp), %rax
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x24, 0x8(%rsp)
callq 0x5740
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_client_list
void
xu_ewmh_net_client_list(struct screen_ctx *sc)
{
	struct client_ctx	*cc;
	Window			*winlist;
	int			 i = 0, j = 0;

	TAILQ_FOREACH(cc, &Clientq, entry)
		i++;
	if (i == 0)
		return;

	winlist = xmalloc(i * sizeof(*winlist));
	TAILQ_FOREACH(cc, &Clientq, entry)
		winlist[j++] = cc->win;
	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_CLIENT_LIST].atom,
	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)winlist, i);
	xfree(winlist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0xde0f(%rip), %rax      # 0x19480
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb695
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb678
cmpl $0x0, -0x1c(%rbp)
jne 0xb6a0
jmp 0xb735
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0x6420
movq %rax, -0x18(%rbp)
leaq 0xddc8(%rip), %rax      # 0x19480
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb6f1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb6bf
leaq 0x110b0(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xde2e(%rip), %rdx      # 0x19538
movq -0x18(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x5740
movq -0x18(%rbp), %rdi
callq 0x64b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_wm_desktop_viewport
void
xu_ewmh_net_wm_desktop_viewport(struct screen_ctx *sc)
{
	long	 viewports[2] = {0, 0};

	/* We don't support large desktops, so this is (0, 0). */
	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_DESKTOP_VIEWPORT].atom,
	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)viewports, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5090
leaq 0x10fe5(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xdd93(%rip), %rdx      # 0x19568
leaq -0x20(%rbp), %rax
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x5740
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_ewmh_net_wm_desktop
void
xu_ewmh_net_wm_desktop(struct client_ctx *cc)
{
	struct group_ctx	*gc = cc->group;
	long			 no = 0xffffffff;

	if (gc)
		no = gc->shortcut - 1;

	XChangeProperty(X_Dpy, cc->win, ewmh[_NET_WM_DESKTOP].atom,
	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&no, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb9eb
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
subl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
leaq 0x10db6(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq 0xdbd4(%rip), %rdx      # 0x195d8
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x18(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x5740
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xutil.c
// Function: xu_getcolor
unsigned long
xu_getcolor(struct screen_ctx *sc, char *name)
{
	XColor	 color, tmp;

	if (!XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, sc->which),
	    name, &color, &tmp)) {
		warnx("XAllocNamedColor error: '%s'", name);
		return (0);
	}

	return (color.pixel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x10d61(%rip), %rax     # 0x1c7a8
movq (%rax), %rdi
leaq 0x10d57(%rip), %rax     # 0x1c7a8
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x5230
cmpl $0x0, %eax
jne 0xba9f
movq -0x18(%rbp), %rsi
leaq 0x89ea(%rip), %rdi      # 0x14478
movb $0x0, %al
callq 0x5140
movq $0x0, -0x8(%rbp)
jmp 0xbaa7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_cmd_add
void
conf_cmd_add(struct conf *c, char *image, char *label, int flags)
{
	/* "term" and "lock" have special meanings. */

	if (strcmp(label, "term") == 0)
		(void)strlcpy(c->termpath, image, sizeof(c->termpath));
	else if (strcmp(label, "lock") == 0)
		(void)strlcpy(c->lockpath, image, sizeof(c->lockpath));
	else {
		struct cmd *cmd = xmalloc(sizeof(*cmd));
		cmd->flags = flags;
		(void)strlcpy(cmd->image, image, sizeof(cmd->image));
		(void)strlcpy(cmd->label, label, sizeof(cmd->label));
		TAILQ_INSERT_TAIL(&c->cmdq, cmd, entry);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x89b4(%rip), %rsi      # 0x14496
callq 0x5610
cmpl $0x0, %eax
jne 0xbb0a
movq -0x8(%rbp), %rdi
addq $0xe0, %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x12ce0
jmp 0xbbbb
movq -0x18(%rbp), %rdi
leaq 0x8987(%rip), %rsi      # 0x1449c
callq 0x5610
cmpl $0x0, %eax
jne 0xbb3a
movq -0x8(%rbp), %rdi
addq $0x10e0, %rdi           # imm = 0x10E0
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x12ce0
jmp 0xbbb9
movl $0x1118, %edi           # imm = 0x1118
callq 0x6420
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x12ce0
movq -0x28(%rbp), %rdi
addq $0x1014, %rdi           # imm = 0x1014
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x12ce0
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xbbb9
jmp 0xbbbb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_setup
void
conf_setup(struct conf *c, const char *conf_file)
{
	char		 conf_path[MAXPATHLEN];
	char		*home;
	struct stat	 sb;
	int		 parse = 0;

	conf_init(c);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10c0, %rsp           # imm = 0x10C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x10ac(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbcc0
cmpq $0x0, -0x10(%rbp)
jne 0xc6b9
leaq 0x7e86(%rip), %rdi      # 0x144be
callq 0x5550
movq %rax, -0x1018(%rbp)
cmpq $0x0, %rax
jne 0xc65d
movl $0x1, %edi
leaq 0x7e6d(%rip), %rsi      # 0x144c3
movb $0x0, %al
callq 0x56f0
leaq -0x1010(%rbp), %rdi
movq -0x1018(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0x7e5f(%rip), %rdx      # 0x144d6
leaq 0x7e5e(%rip), %r8       # 0x144dc
movb $0x0, %al
callq 0x50b0
leaq -0x1010(%rbp), %rdi
leaq -0x10a8(%rbp), %rsi
callq 0x5840
cmpl $0x0, %eax
jne 0xc6b7
movl -0x1090(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xc6b7
movl $0x1, -0x10ac(%rbp)
jmp 0xc733
movq -0x10(%rbp), %rdi
leaq -0x10a8(%rbp), %rsi
callq 0x5840
cmpl $-0x1, %eax
je 0xc6de
movl -0x1090(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0xc712
movq -0x10(%rbp), %rax
movq %rax, -0x10b8(%rbp)
callq 0x5580
movl (%rax), %edi
callq 0x5490
movq -0x10b8(%rbp), %rdx
movq %rax, %rcx
movl $0x1, %edi
leaq 0x7e1f(%rip), %rsi      # 0x1452a
movb $0x0, %al
callq 0x56f0
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x12ce0
movl $0x1, -0x10ac(%rbp)
jmp 0xc733
cmpl $0x0, -0x10ac(%rbp)
je 0xc766
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x127f0
cmpl $-0x1, %eax
jne 0xc766
leaq -0x1010(%rbp), %rsi
leaq 0x7d84(%rip), %rdi      # 0x144e3
movb $0x0, %al
callq 0x5140
addq $0x10c0, %rsp           # imm = 0x10C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_client
void
conf_client(struct client_ctx *cc)
{
	struct winmatch	*wm;
	char		*wname = cc->name;
	int		 ignore = 0;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0xdf27(%rip), %rax      # 0x1a6c0
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc7f6
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5320
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x55d0
cmpl $0x0, %eax
jne 0xc7e7
movl $0x1, -0x1c(%rbp)
jmp 0xc7f6
jmp 0xc7e9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc7a1
cmpl $0x0, -0x1c(%rbp)
je 0xc803
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0xc810
leaq 0xdeb6(%rip), %rax      # 0x1a6c0
movl 0x54(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
orl 0xa8(%rax), %ecx
movl %ecx, 0xa8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_unbind
static void
conf_unbind(struct conf *c, struct keybinding *unbind)
{
	struct keybinding	*key = NULL, *keynxt;

	for (key = TAILQ_FIRST(&c->keybindingq);
	    key != TAILQ_END(&c->keybindingq); key = keynxt) {
		keynxt = TAILQ_NEXT(key, entry);

		if (key->modmask != unbind->modmask)
			continue;

		if ((key->keycode != 0 && key->keysym == NoSymbol &&
		    key->keycode == unbind->keycode) ||
		    key->keysym == unbind->keysym) {
			conf_ungrab(c, key);
			TAILQ_REMOVE(&c->keybindingq, key, entry);
			xfree(key);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc9ec
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0xc94e
jmp 0xc9df
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xc976
movq -0x18(%rbp), %rax
movslq 0x24(%rax), %rax
cmpq $0x0, %rax
jne 0xc976
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0xc986
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0xc9dd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc8a0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc9b2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xc9c2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x64b0
jmp 0xc9df
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc923
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_mouseunbind
static void
conf_mouseunbind(struct conf *c, struct mousebinding *unbind)
{
	struct mousebinding	*mb = NULL, *mbnxt;

	for (mb = TAILQ_FIRST(&c->mousebindingq);
	    mb != TAILQ_END(&c->mousebindingq); mb = mbnxt) {
		mbnxt = TAILQ_NEXT(mb, entry);

		if (mb->modmask != unbind->modmask)
			continue;

		if (mb->button == unbind->button) {
			TAILQ_REMOVE(&c->mousebindingq, mb, entry);
			xfree(mb);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcab7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0xca4c
jmp 0xcaaa
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0xcaa8
jmp 0xca5e
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xca7d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xca8d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x64b0
jmp 0xcaaa
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xca24
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/conf.c
// Function: conf_grab_mouse
void
conf_grab_mouse(struct client_ctx *cc)
{
	struct mousebinding	*mb;
	int			 button;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdbed(%rip), %rax      # 0x1a6c0
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcb69
movq -0x10(%rbp), %rax
cmpl $0x2, 0x20(%rax)
je 0xcaf2
jmp 0xcb59
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0xcb17
jmp 0xcb03
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xcb20
jmp 0xcb0d
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0xcb29
jmp 0xcb32
movl $0x1, -0x14(%rbp)
jmp 0xcb42
movl $0x2, -0x14(%rbp)
jmp 0xcb42
movl $0x3, -0x14(%rbp)
jmp 0xcb42
leaq 0x79f8(%rip), %rdi      # 0x14531
movb $0x0, %al
callq 0x5140
jmp 0xcb59
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movl -0x14(%rbp), %edx
callq 0xab00
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcadb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_keyrelease
static void
xev_handle_keyrelease(XEvent *ee)
{
	XKeyEvent		*e = &ee->xkey;
	struct screen_ctx	*sc;
	struct client_ctx	*cc;
	int			 i, keysym;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6060
movq %rax, -0x18(%rbp)
callq 0x7aa0
movq %rax, -0x20(%rbp)
leaq 0xf9e3(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
xorl %ecx, %ecx
movzbl %al, %esi
movl %ecx, %edx
callq 0x5270
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x6, %rax
jae 0xce20
movslq -0x28(%rbp), %rax
movslq -0x24(%rbp), %rdx
leaq 0xd822(%rip), %rcx      # 0x1a620
cmpq (%rcx,%rdx,8), %rax
jne 0xce13
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8580
jmp 0xce20
jmp 0xce15
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcde5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_buttonpress
static void
xev_handle_buttonpress(XEvent *ee)
{
	XButtonEvent		*e = &ee->xbutton;
	struct client_ctx	*cc, fakecc;
	struct screen_ctx	*sc;
	struct mousebinding	*mb;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6060
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6510
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
andl $-0x13, %ecx
movl %ecx, 0x50(%rax)
leaq 0xd840(%rip), %rax      # 0x1a6c0
movq 0x40(%rax), %rax
movq %rax, -0x130(%rbp)
cmpq $0x0, -0x130(%rbp)
je 0xced2
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x130(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0xcebd
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x130(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0xcebd
jmp 0xced2
jmp 0xcebf
movq -0x130(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x130(%rbp)
jmp 0xce8b
cmpq $0x0, -0x130(%rbp)
jne 0xcede
jmp 0xcf47
movq -0x130(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0xcf27
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x128(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0xcf02
jmp 0xcf47
leaq -0x120(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0xcf32
cmpq $0x0, -0x18(%rbp)
jne 0xcf30
jmp 0xcf47
jmp 0xcf32
movq -0x130(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_unmapnotify
static void
xev_handle_unmapnotify(XEvent *ee)
{
	XUnmapEvent		*e = &ee->xunmap;
	XEvent			ev;
	struct client_ctx	*cc;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf71a(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
callq 0x5120
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6510
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0xd101
leaq 0xf6f1(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0xd8(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0x11, %edx
leaq -0xd0(%rbp), %rcx
callq 0x5100
cmpl $0x0, %eax
jne 0xd0e5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xd0f3
movq -0xd8(%rbp), %rdi
callq 0x7600
jmp 0xd0ff
movq -0xd8(%rbp), %rdi
callq 0x7370
jmp 0xd101
leaq 0xf6a0(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
callq 0x5420
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_maprequest
static void
xev_handle_maprequest(XEvent *ee)
{
	XMapRequestEvent	*e = &ee->xmaprequest;
	struct client_ctx	*cc = NULL, *old_cc;
	XWindowAttributes	 xattr;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x7aa0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd157
movq -0x20(%rbp), %rdi
callq 0x8260
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6510
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xd1bf
leaq 0xf633(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x5710
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x88(%rbp), %rdi
callq 0x6060
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x6570
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xd1da
movq -0x18(%rbp), %rdi
callq 0x81d0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_propertynotify
static void
xev_handle_propertynotify(XEvent *ee)
{
	XPropertyEvent		*e = &ee->xproperty;
	struct screen_ctx	*sc;
	struct client_ctx	*cc;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6510
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd47c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
subq $0x27, %rax
je 0xd462
jmp 0xd43f
movq -0x28(%rbp), %rax
subq $0x28, %rax
je 0xd457
jmp 0xd44b
movq -0x28(%rbp), %rax
subq $0x44, %rax
je 0xd46d
jmp 0xd478
movq -0x20(%rbp), %rdi
callq 0x68b0
jmp 0xd47a
movq -0x20(%rbp), %rdi
callq 0x6b60
jmp 0xd47a
movq -0x20(%rbp), %rdi
callq 0x72d0
jmp 0xd47a
jmp 0xd47a
jmp 0xd4d9
leaq 0xbfed(%rip), %rax      # 0x19470
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd4b4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xd4a5
jmp 0xd4b6
jmp 0xd4a7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd48a
jmp 0xd4d9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xc03b(%rip), %rcx      # 0x19500
cmpq 0xa8(%rcx), %rax
jne 0xd4d7
movq -0x18(%rbp), %rdi
callq 0xd8d0
jmp 0xd4d9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/xevents.c
// Function: xev_handle_clientmessage
static void
xev_handle_clientmessage(XEvent *ee)
{
	XClientMessageEvent	*e = &ee->xclient;
	Atom			 xa_wm_change_state;
	struct client_ctx	*cc;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf2ad(%rip), %rax      # 0x1c7a8
movq (%rax), %rdi
leaq 0x7418(%rip), %rsi      # 0x1491d
xorl %edx, %edx
callq 0x5690
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6510
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xd529
jmp 0xd555
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xd555
movq -0x10(%rbp), %rax
cmpl $0x20, 0x30(%rax)
jne 0xd555
movq -0x10(%rbp), %rax
cmpq $0x3, 0x38(%rax)
jne 0xd555
movq -0x20(%rbp), %rdi
callq 0x7370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)