LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: enter
void
enter(XCrossingEvent * e)
{
	Client *c;

	curtime = e->time;
	if (e->mode != NotifyGrab || e->detail != NotifyNonlinearVirtual)
		return;
	c = getclient(e->window, 0);
	if (c != 0 && c != current) {
		/*
		 * someone grabbed the pointer; make them current 
		 */
		XMapRaised(dpy, c->parent);
		top(c);
		active(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %ecx
leaq 0x7ebb(%rip), %rax      # 0xc998
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x50(%rax)
jne 0x4af3
movq -0x8(%rbp), %rax
cmpl $0x4, 0x54(%rax)
je 0x4af5
jmp 0x4b4e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4b4e
movq -0x10(%rbp), %rax
leaq 0x8014(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
je 0x4b4e
leaq 0x7e50(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2340
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6df0
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6b40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/event.c
// Function: focusin
void
focusin(XFocusChangeEvent * e)
{
	Client *c;

	curtime = CurrentTime;
	if (e->detail != NotifyNonlinearVirtual)
		return;
	c = getclient(e->window, 0);
	if (c != 0 && c->window == e->window && c != current) {
		/*
		 * someone grabbed keyboard or seized focus; make them current 
		 */
		XMapRaised(dpy, c->parent);
		top(c);
		active(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7e25(%rip), %rax      # 0xc998
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x4, 0x2c(%rax)
je 0x4b85
jmp 0x4bef
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4bef
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x4bef
movq -0x10(%rbp), %rax
leaq 0x7f73(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
je 0x4bef
leaq 0x7daf(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2340
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6df0
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6b40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: scanwins
void
scanwins(ScreenInfo * s)
{
	unsigned int i, nwins;
	Client *c;
	Window dw1, dw2, *wins;
	XWindowAttributes attr;

	XQueryTree(dpy, s->root, &dw1, &dw2, &wins, &nwins);
	for (i = 0; i < nwins; i++) {
		XGetWindowAttributes(dpy, wins[i], &attr);
		if (attr.override_redirect || wins[i] == s->menuwin)
			continue;
		c = getclient(wins[i], 1);
		if (c != 0 && c->window == wins[i] && !c->init) {
			c->x = attr.x;
			c->y = attr.y;
			c->dx = attr.width;
			c->dy = attr.height;
			c->border = attr.border_width;
			c->screen = s;
			c->parent = s->root;
			if (attr.map_state == IsViewable)
				manage(c, 1);
		}
	}
	XFree((void *) wins);	/* cast is to shut stoopid compiler up */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x76e2(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x10(%rbp), %r9
callq 0x2140
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x53db
leaq 0x76a8(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x2490
cmpl $0x0, -0x40(%rbp)
jne 0x5305
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x530a
jmp 0x53cd
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x53cb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jne 0x53cb
movq -0x18(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
jne 0x53cb
movl -0xb8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0xb4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0xb0(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0xac(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0xa8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x2, -0x5c(%rbp)
jne 0x53c9
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4c00
jmp 0x53cb
jmp 0x53cd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52bd
movq -0x30(%rbp), %rdi
callq 0x2180
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: gettrans
void
gettrans(Client * c)
{
	Window trans;

	trans = None;
	if (XGetTransientForHint(dpy, c->window, &trans) != 0)
		c->trans = trans;
	else
		c->trans = None;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x756d(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2460
cmpl $0x0, %eax
je 0x5431
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x543d
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: withdraw
void
withdraw(Client * c)
{
	XUnmapWindow(dpy, c->parent);
	gravitate(c, 1);
	XReparentWindow(dpy, c->window, c->screen->root, c->x, c->y);
	gravitate(c, 0);
	XRemoveFromSaveSet(dpy, c->window);
	setwstate(c, WithdrawnState);

	/*
	 * flush any errors 
	 */
	ignore_badwindow = 1;
	XSync(dpy, False);
	ignore_badwindow = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7515(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2420
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5520
leaq 0x74f0(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %r8d
callq 0x2050
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5520
leaq 0x74b1(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x23d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5d00
leaq 0x7680(%rip), %rax      # 0xcb68
movl $0x1, (%rax)
leaq 0x7483(%rip), %rax      # 0xc978
movq (%rax), %rdi
xorl %esi, %esi
callq 0x23a0
leaq 0x7662(%rip), %rax      # 0xcb68
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: cmapfocus
void
cmapfocus(Client * c)
{
	int i, found;
	Client *cc;

	if (c == 0)
		return;
	else if (c->ncmapwins != 0) {
		found = 0;
		for (i = c->ncmapwins - 1; i >= 0; i--) {
			installcmap(c->screen, c->wmcmaps[i]);
			if (c->cmapwins[i] == c->window)
				found++;
		}
		if (!found)
			installcmap(c->screen, c->cmap);
	} else if (c->trans != None && (cc = getclient(c->trans, 0)) != 0 && cc->ncmapwins != 0)
		cmapfocus(cc);
	else
		installcmap(c->screen, c->cmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x56c8
jmp 0x57cb
movq -0x8(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0x576e
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xe0(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x574b
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x57e0
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x573e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5740
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x56f0
cmpl $0x0, -0x10(%rbp)
jne 0x576c
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rsi
callq 0x57e0
jmp 0x57c9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x57ac
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6e90
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x57ac
movq -0x18(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0x57ac
movq -0x18(%rbp), %rdi
callq 0x56b0
jmp 0x57c7
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rsi
callq 0x57e0
jmp 0x57c9
jmp 0x57cb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: getcmaps
void
getcmaps(Client * c)
{
	int n, i;
	Window *cw;
	XWindowAttributes attr;

	if (!c->init) {
		XGetWindowAttributes(dpy, c->window, &attr);
		c->cmap = attr.colormap;
	}

	n = _getprop(c->window, wm_colormaps, XA_WINDOW, 100L, (unsigned char **) &cw);
	if (c->ncmapwins != 0) {
		XFree((char *) c->cmapwins);
		free((char *) c->wmcmaps);
	}
	if (n <= 0) {
		c->ncmapwins = 0;
		return;
	}

	c->ncmapwins = n;
	c->cmapwins = cw;

	c->wmcmaps = (Colormap *) malloc(n * sizeof(Colormap));
	for (i = 0; i < n; i++) {
		if (cw[i] == c->window)
			c->wmcmaps[i] = c->cmap;
		else {
			XSelectInput(dpy, cw[i], ColormapChangeMask);
			XGetWindowAttributes(dpy, cw[i], &attr);
			c->wmcmaps[i] = attr.colormap;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
jne 0x5898
leaq 0x7105(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x2490
movq -0x50(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x7122(%rip), %rax      # 0xc9c8
movq (%rax), %rsi
movl $0x21, %edx
movl $0x64, %ecx
leaq -0x18(%rbp), %r8
callq 0x5b20
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0x58ec
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x2080
cmpl $0x0, -0xc(%rbp)
jg 0x5905
movq -0x8(%rbp), %rax
movl $0x0, 0xe0(%rax)
jmp 0x59ed
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe0(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe8(%rax)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2330
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xf0(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x59ed
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5984
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x59dd
leaq 0x6fed(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x800000, %edx         # imm = 0x800000
callq 0x23b0
leaq 0x6fcd(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x2490
movq -0x50(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x59df
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5943
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: setlabel
void
setlabel(Client * c)
{
	char *label, *p;

	if (c->iconname != 0) {
		label = c->iconname;
	} else if (c->name != 0) {
		label = c->name;
	} else if (c->instance != 0) {
		label = c->instance;
	} else if (c->class != 0) {
		label = c->class;
	} else {
		label = "no label";
	}
	while ((p = strstr(label, " - "))) {
		label = p + 3;
	}
	if ((p = strchr(label, ':')) != 0)
		*p = '\0';
	for (; *label == ' '; label += 1);
	c->label = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x5a2b
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a99
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x5a4a
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a97
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x5a69
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a95
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x5a88
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a93
leaq 0x3b8e(%rip), %rax      # 0x961d
movq %rax, -0x10(%rbp)
jmp 0x5a95
jmp 0x5a97
jmp 0x5a99
jmp 0x5a9b
movq -0x10(%rbp), %rdi
leaq 0x3b80(%rip), %rsi      # 0x9626
callq 0x25d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5ac3
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x5a9b
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x2170
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5ae2
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x5ae4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x5b00
jmp 0x5af2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5ae4
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: getprop
int
_getprop(Window w, Atom a, Atom type, long len, unsigned char **p)
{
	Atom real_type;
	int format;
	unsigned long n, extra;
	int status;

	status = XGetWindowProperty(dpy, w, a, 0L, len, False, type, &real_type, &format, &n, &extra, p);
	if (status != Success || *p == 0)
		return -1;
	if (n == 0)
		XFree((void *) *p);
	/*
	 * could check real_type, format, extra here... 
	 */
	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 0x6e2d(%rip), %rax      # 0xc978
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 -0x54(%rbp), %rbx
leaq -0x60(%rbp), %r11
leaq -0x68(%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 0x2540
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jne 0x5bac
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5bb5
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bcf
cmpq $0x0, -0x60(%rbp)
jne 0x5bc8
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x2180
movq -0x60(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: get1prop
int
get1prop(Window w, Atom a, Atom type)
{
	unsigned char *p;
	int ret;

	if (_getprop(w, a, type, 1L, &p) <= 0) {
		return 0;
	}
	ret = (int) (unsigned long int) (*p);
	XFree((void *) p);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
leaq -0x28(%rbp), %r8
callq 0x5b20
cmpl $0x0, %eax
jg 0x5c7c
movl $0x0, -0x4(%rbp)
jmp 0x5c95
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2180
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: setwstate
void
setwstate(Client * c, int state)
{
	long data[2];

	data[0] = (long) state;
	data[1] = (long) None;

	c->state = state;
	XChangeProperty(dpy, c->window, wm_state, wm_state, 32, PropModeReplace, (unsigned char *) data, 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, 0x98(%rax)
leaq 0x6c45(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x6c5c(%rip), %rax      # 0xc9a0
movq (%rax), %rdx
leaq 0x6c52(%rip), %rax      # 0xc9a0
movq (%rax), %rcx
leaq -0x20(%rbp), %rax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x2360
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: getwstate
int
getwstate(Window w, int *state)
{
	long *p = 0;

	if (_getprop(w, wm_state, wm_state, 2L, (unsigned char **) &p) <= 0)
		return 0;

	*state = (int) *p;
	XFree((char *) p);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6bfd(%rip), %rax      # 0xc9a0
movq (%rax), %rsi
leaq 0x6bf3(%rip), %rax      # 0xc9a0
movq (%rax), %rdx
movl $0x2, %ecx
leaq -0x20(%rbp), %r8
callq 0x5b20
cmpl $0x0, %eax
jg 0x5dcc
movl $0x0, -0x4(%rbp)
jmp 0x5deb
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2180
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/manage.c
// Function: getproto
void
getproto(Client * c)
{
	Atom *p;
	int i;
	long n;
	Window w;

	w = c->window;
	c->proto = 0;
	if ((n = _getprop(w, wm_protocols, XA_ATOM, 20L, (unsigned char **) &p)) <= 0)
		return;

	for (i = 0; i < n; i++)
		if (p[i] == wm_delete)
			c->proto |= Pdelete;
		else if (p[i] == wm_take_focus)
			c->proto |= Ptakefocus;

	XFree((char *) p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x28(%rbp), %rdi
leaq 0x6b80(%rip), %rax      # 0xc9b0
movq (%rax), %rsi
movl $0x4, %edx
movl $0x14, %ecx
leaq -0x10(%rbp), %r8
callq 0x5b20
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jg 0x5e57
jmp 0x5ed8
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x5ecf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x6b3d(%rip), %rcx      # 0xc9b8
cmpq (%rcx), %rax
jne 0x5e95
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xa8(%rax)
jmp 0x5ec2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x6b18(%rip), %rcx      # 0xc9c0
cmpq (%rcx), %rax
jne 0x5ec0
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xa8(%rax)
jmp 0x5ec2
jmp 0x5ec4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5e5e
movq -0x10(%rbp), %rdi
callq 0x2180
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: spawn
void
spawn(ScreenInfo * s, char *prog)
{
	if (fork() == 0) {
		close(ConnectionNumber(dpy));
		if (s->display[0] != '\0') {
			putenv(s->display);
		}

		if (prog != NULL) {
			execl(shell, shell, "-c", prog, NULL);
			fprintf(stderr, "9wm: exec %s", shell);
			perror(" failed");
		}
		execlp("xterm", "xterm", NULL);
		perror("9wm: exec xterm failed");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x25c0
cmpl $0x0, %eax
jne 0x6295
leaq 0x6793(%rip), %rax      # 0xc978
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x2220
movq -0x8(%rbp), %rax
movsbl 0x78(%rax), %eax
cmpl $0x0, %eax
je 0x620a
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
callq 0x2250
cmpq $0x0, -0x10(%rbp)
je 0x626a
leaq 0x6758(%rip), %rax      # 0xc970
movq (%rax), %rdi
leaq 0x674e(%rip), %rax      # 0xc970
movq (%rax), %rsi
movq -0x10(%rbp), %rcx
leaq 0x3438(%rip), %rdx      # 0x9668
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2580
movq 0x5db5(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x6723(%rip), %rax      # 0xc970
movq (%rax), %rdx
leaq 0x3414(%rip), %rsi      # 0x966b
movb $0x0, %al
callq 0x22b0
leaq 0x32fc(%rip), %rdi      # 0x9561
callq 0x24a0
leaq 0x3407(%rip), %rsi      # 0x9678
xorl %eax, %eax
movl %eax, %edx
movq %rsi, %rdi
movb $0x0, %al
callq 0x2560
leaq 0x33f8(%rip), %rdi      # 0x967e
callq 0x24a0
movl $0x1, %edi
callq 0x2520
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: reshape
void
reshape(c)
     Client *c;
{
	int odx, ody;

	if (c == 0)
		return;
	odx = c->dx;
	ody = c->dy;
	if (sweep(c) == 0)
		return;
	active(c);
	top(c);
	XRaiseWindow(dpy, c->parent);
	XMoveResizeWindow(dpy, c->parent, c->x - BORDER, c->y - BORDER, c->dx + 2 * (BORDER - 1), c->dy + 2 * (BORDER - 1));
	if (c->dx == odx && c->dy == ody)
		sendconfig(c);
	else
		XMoveResizeWindow(dpy, c->window, BORDER - 1, BORDER - 1, c->dx, c->dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x62b8
jmp 0x63da
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x86d0
cmpl $0x0, %eax
jne 0x62e1
jmp 0x63da
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x6b40
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x6df0
leaq 0x667a(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2570
leaq 0x6663(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x5ff2(%rip), %rax      # 0xc320
subl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
leaq 0x5fe2(%rip), %rax      # 0xc320
subl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r8d
leaq 0x5fd1(%rip), %rax      # 0xc320
movl (%rax), %eax
subl $0x1, %eax
shll %eax
addl %eax, %r8d
movq -0x8(%rbp), %rax
movl 0x34(%rax), %r9d
leaq 0x5fb8(%rip), %rax      # 0xc320
movl (%rax), %eax
subl $0x1, %eax
shll %eax
addl %eax, %r9d
callq 0x21b0
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x639c
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x639c
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x3540
jmp 0x63da
leaq 0x65d5(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x5f6c(%rip), %rax      # 0xc320
movl (%rax), %edx
subl $0x1, %edx
leaq 0x5f60(%rip), %rax      # 0xc320
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x34(%rax), %r9d
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: move
void
move(Client * c)
{
	if (c == 0)
		return;
	if (drag(c) == 0)
		return;
	active(c);
	top(c);
	XRaiseWindow(dpy, c->parent);
	XMoveWindow(dpy, c->parent, c->x - BORDER, c->y - BORDER);
	sendconfig(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x63f8
jmp 0x6479
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x8840
cmpl $0x0, %eax
jne 0x640a
jmp 0x6479
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x6b40
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x6df0
leaq 0x6551(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2570
leaq 0x653a(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x5ec9(%rip), %rax      # 0xc320
subl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
leaq 0x5eb9(%rip), %rax      # 0xc320
subl (%rax), %ecx
callq 0x2190
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x3540
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: delete
void
delete(c, shift)
     Client *c;
     int shift;
{
	if (c == 0)
		return;
	if ((c->proto & Pdelete) && !shift)
		sendcmessage(c->window, wm_protocols, wm_delete, 0);
	else
		XKillClient(dpy, c->window);	/* let event clean up */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6498
jmp 0x64ec
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x64d6
cmpl $0x0, -0xc(%rbp)
jne 0x64d6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x64f2(%rip), %rax      # 0xc9b0
movq (%rax), %rsi
leaq 0x64f0(%rip), %rax      # 0xc9b8
movq (%rax), %rdx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x3460
jmp 0x64ec
leaq 0x649b(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x2110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: hide
void
hide(Client * c)
{
	int i;

	if (c == 0 || numhidden == MAXHIDDEN)
		return;
	if (hidden(c)) {
		fprintf(stderr, "9wm: already hidden: %s\n", c->label);
		return;
	}
	XUnmapWindow(dpy, c->parent);
	XUnmapWindow(dpy, c->window);
	setwstate(c, IconicState);
	if (c == current)
		nofocus();

	for (i = numhidden; i > 0; i -= 1) {
		hiddenc[i] = hiddenc[i - 1];
		b3items[B3FIXED + i] = b3items[B3FIXED + i - 1];
	}
	hiddenc[0] = c;
	b3items[B3FIXED] = c->label;
	numhidden++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x651c
cmpl $0x20, 0x6506(%rip)     # 0xca20
jne 0x6521
jmp 0x663e
movq -0x8(%rbp), %rax
cmpl $0x3, 0x98(%rax)
jne 0x6556
movq 0x5ac3(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdx
leaq 0x314b(%rip), %rsi      # 0x9695
movb $0x0, %al
callq 0x22b0
jmp 0x663e
leaq 0x641b(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2420
leaq 0x6404(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x2420
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movb $0x0, %al
callq 0x5d00
movq -0x8(%rbp), %rax
leaq 0x6592(%rip), %rcx      # 0xcb30
cmpq (%rcx), %rax
jne 0x65aa
movb $0x0, %al
callq 0x6c80
movl 0x6470(%rip), %eax      # 0xca20
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x6612
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x6467(%rip), %rax      # 0xca30
movq (%rax,%rcx,8), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x6458(%rip), %rax      # 0xca30
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x5, %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x5d91(%rip), %rax      # 0xc380
movq (%rax,%rcx,8), %rdx
movl -0xc(%rbp), %eax
addl $0x5, %eax
movslq %eax, %rcx
leaq 0x5d7d(%rip), %rax      # 0xc380
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x65b3
movq -0x8(%rbp), %rax
movq %rax, 0x6413(%rip)      # 0xca30
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x5d79(%rip)      # 0xc3a8
movl 0x63eb(%rip), %eax      # 0xca20
addl $0x1, %eax
movl %eax, 0x63e2(%rip)      # 0xca20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: unhide
void
unhide(int n, int map)
{
	Client *c;
	int i;

	if (n >= numhidden) {
		fprintf(stderr, "9wm: unhide: n %d numhidden %d\n", n, numhidden);
		return;
	}
	c = hiddenc[n];
	if (!hidden(c)) {
		fprintf(stderr, "9wm: unhide: not hidden: %s(0x%x)\n", c->label, (int) c->window);
		return;
	}

	if (map) {
		XMapWindow(dpy, c->window);
		XMapRaised(dpy, c->parent);
		setwstate(c, NormalState);
		active(c);
		top(c);
	}

	numhidden--;
	for (i = n; i < numhidden; i++) {
		hiddenc[i] = hiddenc[i + 1];
		b3items[B3FIXED + i] = b3items[B3FIXED + i + 1];
	}
	b3items[B3FIXED + numhidden] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x63b9(%rip), %eax      # 0xca20
jl 0x668f
movq 0x5988(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movl 0x63a4(%rip), %ecx      # 0xca20
leaq 0x302b(%rip), %rsi      # 0x96ae
movb $0x0, %al
callq 0x22b0
jmp 0x67cd
movslq -0x4(%rbp), %rcx
leaq 0x6396(%rip), %rax      # 0xca30
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x98(%rax)
je 0x66e0
movq 0x5942(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
leaq 0x2ffa(%rip), %rsi      # 0x96ce
movb $0x0, %al
callq 0x22b0
jmp 0x67cd
cmpl $0x0, -0x8(%rbp)
je 0x6739
leaq 0x628b(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x24c0
leaq 0x6275(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2340
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x5d00
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6b40
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x6df0
movl 0x62e1(%rip), %eax      # 0xca20
addl $-0x1, %eax
movl %eax, 0x62d8(%rip)      # 0xca20
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x62c9(%rip), %eax      # 0xca20
jge 0x67b2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x62c7(%rip), %rax      # 0xca30
movq (%rax,%rcx,8), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x62b8(%rip), %rax      # 0xca30
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x5, %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x5bf1(%rip), %rax      # 0xc380
movq (%rax,%rcx,8), %rdx
movl -0x14(%rbp), %eax
addl $0x5, %eax
movslq %eax, %rcx
leaq 0x5bdd(%rip), %rax      # 0xc380
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x674e
movl 0x6268(%rip), %eax      # 0xca20
addl $0x5, %eax
movslq %eax, %rcx
leaq 0x5bbb(%rip), %rax      # 0xc380
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: unhidec
void
unhidec(c, map)
     Client *c;
     int map;
{
	int i;

	for (i = 0; i < numhidden; i++)
		if (c == hiddenc[i]) {
			unhide(i, map);
			return;
		}
	fprintf(stderr, "9wm: unhidec: not hidden: %s(0x%x)\n", c->label, (int) c->window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x6221(%rip), %eax      # 0xca20
jge 0x6830
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
leaq 0x6220(%rip), %rcx      # 0xca30
cmpq (%rcx,%rdx,8), %rax
jne 0x6823
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x6650
jmp 0x685c
jmp 0x6825
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x67f6
movq 0x57c1(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
leaq 0x2e9c(%rip), %rsi      # 0x96f1
movb $0x0, %al
callq 0x22b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/menu.c
// Function: renamec
void
renamec(c, name)
     Client *c;
     char *name;
{
	int i;

	if (name == 0)
		name = "???";
	c->label = name;
	if (!hidden(c))
		return;
	for (i = 0; i < numhidden; i++)
		if (c == hiddenc[i]) {
			b3items[B3FIXED + i] = name;
			return;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x688e
leaq 0x2e8b(%rip), %rax      # 0x9715
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x98(%rax)
je 0x68ac
jmp 0x68fa
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x6164(%rip), %eax      # 0xca20
jge 0x68fa
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0x6163(%rip), %rcx      # 0xca30
cmpq (%rcx,%rdx,8), %rax
jne 0x68ed
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %eax
addl $0x5, %eax
movslq %eax, %rcx
leaq 0x5a99(%rip), %rax      # 0xc380
movq %rdx, (%rax,%rcx,8)
jmp 0x68fa
jmp 0x68ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x68b3
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: setactive
void
setactive(Client * c, int on)
{
	if (c->parent == c->screen->root) {
		return;
	}
	if (on) {
		XUngrabButton(dpy, AnyButton, AnyModifier, c->parent);
		XSetInputFocus(dpy, c->window, RevertToPointerRoot, timestamp());
		if (c->proto & Ptakefocus)
			sendcmessage(c->window, wm_protocols, wm_take_focus, 0);
		cmapfocus(c);
	} else
		XGrabButton(dpy, AnyButton, AnyModifier, c->parent, False, ButtonMask, GrabModeAsync, GrabModeSync, None, None);
	draw_border(c, on);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x692d
jmp 0x6a24
cmpl $0x0, -0xc(%rbp)
je 0x69cd
leaq 0x603a(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x20e0
leaq 0x601c(%rip), %rax      # 0xc978
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, %al
callq 0x33c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x25b0
movq -0x8(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x69c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x6006(%rip), %rax      # 0xc9b0
movq (%rax), %rsi
leaq 0x600c(%rip), %rax      # 0xc9c0
movq (%rax), %rdx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x3460
movq -0x8(%rbp), %rdi
movb $0x0, %al
callq 0x56b0
jmp 0x6a18
leaq 0x5fa4(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %r8d, %r8d
movl $0x8000, %edx           # imm = 0x8000
movl $0xc, %r9d
xorl %eax, %eax
movl %r8d, %esi
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6a30
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: draw_border
void
draw_border(Client * c, int active)
{
	XSetWindowBackground(dpy, c->parent, active ? c->screen->active : c->screen->inactive);
	XClearWindow(dpy, c->parent);
	if (c->hold && active)
		XDrawRectangle(dpy, c->parent, c->screen->gc, INSET, INSET, c->dx + BORDER - INSET, c->dy + BORDER - INSET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x5f32(%rip), %rax      # 0xc978
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6a74
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6a87
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
callq 0x24f0
leaq 0x5ed9(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2090
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
je 0x6b35
cmpl $0x0, -0xc(%rbp)
je 0x6b35
leaq 0x5eaf(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq 0x20(%rax), %rdx
leaq 0x583a(%rip), %rax      # 0xc324
movl (%rax), %ecx
leaq 0x5831(%rip), %rax      # 0xc324
movl (%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r9d
leaq 0x581b(%rip), %rax      # 0xc320
addl (%rax), %r9d
leaq 0x5815(%rip), %rax      # 0xc324
subl (%rax), %r9d
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
leaq 0x5800(%rip), %r10      # 0xc320
addl (%r10), %eax
leaq 0x57fa(%rip), %r10      # 0xc324
subl (%r10), %eax
movl %eax, (%rsp)
callq 0x20c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: active
void
active(Client * c)
{
	Client *cc;

	if (c == 0) {
		fprintf(stderr, "9wm: active(c==0)\n");
		return;
	}
	if (c == current)
		return;
	if (current) {
		setactive(current, 0);
		if (current->screen != c->screen)
			cmapnofocus(current->screen);
	}
	setactive(c, 1);
	for (cc = clients; cc; cc = cc->next)
		if (cc->revert == c)
			cc->revert = c->revert;
	c->revert = current;
	while (c->revert && !normal(c->revert))
		c->revert = c->revert->revert;
	current = c;
#ifdef	DEBUG
	if (debug)
		dump_revert();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6b70
movq 0x549e(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x2bb5(%rip), %rsi      # 0x9719
movb $0x0, %al
callq 0x22b0
jmp 0x6c7a
movq -0x8(%rbp), %rax
cmpq 0x5fb5(%rip), %rax      # 0xcb30
jne 0x6b82
jmp 0x6c7a
cmpq $0x0, 0x5fa6(%rip)      # 0xcb30
je 0x6bcc
movq 0x5f9d(%rip), %rdi      # 0xcb30
xorl %esi, %esi
callq 0x6900
movq 0x5f8f(%rip), %rax      # 0xcb30
movq 0xf8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
je 0x6bca
movq 0x5f74(%rip), %rax      # 0xcb30
movq 0xf8(%rax), %rdi
movb $0x0, %al
callq 0x5830
jmp 0x6bcc
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6900
movq 0x5f57(%rip), %rax      # 0xcb38
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c1a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6c0a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x6c0c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6be5
movq 0x5f0f(%rip), %rcx      # 0xcb30
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x11(%rbp)
je 0x6c50
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, 0x98(%rax)
sete %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6c59
jmp 0x6c6f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x6c29
movq -0x8(%rbp), %rax
movq %rax, 0x5eb6(%rip)      # 0xcb30
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: nofocus
void
nofocus(void)
{
	static Window w = 0;
	int mask;
	XSetWindowAttributes attr;
	Client *c;

	if (current) {
		setactive(current, 0);
		for (c = current->revert; c; c = c->revert)
			if (normal(c)) {
				active(c);
				return;
			}
		cmapnofocus(current->screen);
		/*
		 * if no candidates to revert to, fall through 
		 */
	}
	current = 0;
	if (w == 0) {
		mask = CWOverrideRedirect;
		attr.override_redirect = 1;
		w = XCreateWindow(dpy, screens[0].root, 0, 0, 1, 1, 0, CopyFromParent, InputOnly, CopyFromParent, mask, &attr);
		XMapWindow(dpy, w);
	}
	XSetInputFocus(dpy, w, RevertToPointerRoot, timestamp());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
cmpq $0x0, 0x5e9d(%rip)      # 0xcb30
je 0x6cf9
movq 0x5e94(%rip), %rdi      # 0xcb30
xorl %esi, %esi
callq 0x6900
movq 0x5e86(%rip), %rax      # 0xcb30
movq 0x20(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x6ce4
movq -0x80(%rbp), %rax
cmpl $0x1, 0x98(%rax)
jne 0x6cd4
movq -0x80(%rbp), %rdi
callq 0x6b40
jmp 0x6ddc
jmp 0x6cd6
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x80(%rbp)
jmp 0x6cb2
movq 0x5e45(%rip), %rax      # 0xcb30
movq 0xf8(%rax), %rdi
movb $0x0, %al
callq 0x5830
movq $0x0, 0x5e2c(%rip) # 0xcb30
cmpq $0x0, 0x5e34(%rip)      # 0xcb40
jne 0x6d9b
movl $0x200, -0x4(%rbp)      # imm = 0x200
movl $0x1, -0x20(%rbp)
leaq 0x5c51(%rip), %rax      # 0xc978
movq (%rax), %rdi
leaq 0x5cdf(%rip), %rax      # 0xca10
movq (%rax), %rax
movq 0x8(%rax), %rsi
movslq -0x4(%rbp), %r10
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %eax, %eax
leaq -0x78(%rbp), %rax
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x2, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x2380
movq %rax, 0x5dbb(%rip)      # 0xcb40
leaq 0x5bec(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq 0x5daa(%rip), %rsi      # 0xcb40
callq 0x24c0
leaq 0x5bd6(%rip), %rax      # 0xc978
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq 0x5d8d(%rip), %rax      # 0xcb40
movq %rax, -0x88(%rbp)
movb $0x0, %al
callq 0x33c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x25b0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: top
void
top(Client * c)
{
	Client **l, *cc;

	l = &clients;
	for (cc = *l; cc; cc = *l) {
		if (cc == c) {
			*l = c->next;
			c->next = clients;
			clients = c;
			return;
		}
		l = &cc->next;
	}
	fprintf(stderr, "9wm: %p not on client list in top()\n", (void *) c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5d35(%rip), %rax      # 0xcb38
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e67
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x6e4e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x5cff(%rip), %rcx      # 0xcb38
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x5cec(%rip)      # 0xcb38
jmp 0x6e83
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6e12
movq 0x518a(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x28b0(%rip), %rsi      # 0x972c
movb $0x0, %al
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/client.c
// Function: getclient
Client *
getclient(Window w, int create)
{
	Client *c;

	if (w == 0 || getscreen(w))
		return 0;

	for (c = clients; c; c = c->next)
		if (c->window == w || c->parent == w)
			return c;

	if (!create)
		return 0;

	c = (Client *) malloc(sizeof(Client));
	memset(c, 0, sizeof(Client));
	c->window = w;
	/*
	 * c->parent will be set by the caller 
	 */
	c->parent = None;
	c->reparenting = 0;
	c->state = WithdrawnState;
	c->init = 0;
	c->cmap = None;
	c->label = c->class = 0;
	c->revert = 0;
	c->hold = 0;
	c->ncmapwins = 0;
	c->cmapwins = 0;
	c->wmcmaps = 0;
	c->next = clients;
	clients = c;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6eb7
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x3350
cmpq $0x0, %rax
je 0x6ec4
movq $0x0, -0x8(%rbp)
jmp 0x7015
movq 0x5c6d(%rip), %rax      # 0xcb38
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6f0e
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x6ef1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6efe
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7015
jmp 0x6f00
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6ecf
cmpl $0x0, -0x14(%rbp)
jne 0x6f21
movq $0x0, -0x8(%rbp)
jmp 0x7015
movl $0x100, %edi            # imm = 0x100
callq 0x2330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x21e0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xa0(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x9c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xa4(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq 0x5b3e(%rip), %rcx      # 0xcb38
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x5b2b(%rip)      # 0xcb38
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/grab.c
// Function: grab
int
grab(Window w, Window constrain, int mask, Cursor curs, int t)
{
	int status;

	if (t == 0)
		t = timestamp();
	status = XGrabPointer(dpy, w, False, mask, GrabModeAsync, GrabModeAsync, constrain, curs, t);
	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x731b
movb $0x0, %al
callq 0x33c0
movl %eax, -0x24(%rbp)
leaq 0x5656(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %r11
movq -0x20(%rbp), %r10
movslq -0x24(%rbp), %rax
xorl %edx, %edx
movl $0x1, %r9d
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2210
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/9wm[P]9wm/grab.c
// Function: ungrab
void
ungrab(XButtonEvent * e)
{
	XEvent ev;

	if (!nobuttons(e))
		for (;;) {
			XMaskEvent(dpy, ButtonMask | ButtonMotionMask, &ev);
			if (ev.type == MotionNotify)
				continue;
			e = &ev.xbutton;
			if (nobuttons(e))
				break;
		}
	XUngrabPointer(dpy, e->time);
	curtime = e->time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x72a0
cmpl $0x0, %eax
jne 0x73d4
jmp 0x738f
leaq 0x55e2(%rip), %rax      # 0xc978
movq (%rax), %rdi
movl $0x200c, %esi           # imm = 0x200C
leaq -0xc8(%rbp), %rdx
callq 0x25e0
cmpl $0x6, -0xc8(%rbp)
jne 0x73b5
jmp 0x738f
leaq -0xc8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x72a0
cmpl $0x0, %eax
je 0x73d0
jmp 0x73d2
jmp 0x738f
jmp 0x73d4
leaq 0x559d(%rip), %rax      # 0xc978
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x22e0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %ecx
leaq 0x559c(%rip), %rax      # 0xc998
movl %ecx, (%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)