LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/event.c
// Function: reparent
void
reparent(XReparentEvent * e)
{
	Client *c;
	XWindowAttributes attr;
	ScreenInfo *s;

	/*
	 * we don't set curtime as nothing here uses it 
	 */
	if (!getscreen(e->event) || e->override_redirect)
		return;
	if ((s = getscreen(e->parent)) != 0) {
		c = getclient(e->window, 1);
		if (c != 0 && (c->dx == 0 || c->dy == 0)) {
			XGetWindowAttributes(dpy, c->window, &attr);
			c->x = attr.x;
			c->y = attr.y;
			c->dx = attr.width;
			c->dy = attr.height;
			c->border = attr.border_width;
			c->screen = s;
			if (c->parent == None)
				c->parent = c->screen->root;
		}
	} else {
		c = getclient(e->window, 0);
		if (c != 0 && (c->parent == c->screen->root || withdrawn(c)))
			rmclient(c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movq 0x20(%rdi), %rdi
xorl %eax, %eax
callq 0x340c
testq %rax, %rax
je 0x4172
cmpl $0x0, 0x40(%r14)
je 0x417f
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x30(%r14), %rdi
xorl %eax, %eax
callq 0x340c
movq 0x28(%r14), %rdi
testq %rax, %rax
je 0x421b
movq %rax, %rbx
movl $0x1, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x4172
movq %rax, %r14
cmpl $0x0, 0x30(%rax)
je 0x41bb
cmpl $0x0, 0x34(%r14)
jne 0x4172
leaq 0x77b6(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq (%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x2490
movl (%r15), %eax
movl %eax, 0x28(%r14)
movl 0x4(%r15), %eax
movl %eax, 0x2c(%r14)
movl 0x8(%r15), %eax
movl %eax, 0x30(%r14)
movl 0xc(%r15), %eax
movl %eax, 0x34(%r14)
movl 0x10(%r15), %eax
movl %eax, 0x38(%r14)
movq %rbx, 0xf8(%r14)
cmpq $0x0, 0x8(%r14)
jne 0x4172
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x4172
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x4172
movq 0x8(%rax), %rcx
movq 0xf8(%rax), %rdx
cmpq 0x8(%rdx), %rcx
je 0x424b
cmpl $0x0, 0x98(%rax)
jne 0x4172
movq %rax, %rdi
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x59ab
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl 0x38(%rdi), %eax
leaq 0x772c(%rip), %rcx      # 0xb998
movl %eax, (%rcx)
cmpl $0x1, 0x50(%rdi)
jne 0x42c3
cmpl $0x4, 0x54(%rdi)
jne 0x42c3
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x42c3
movq %rax, %rbx
leaq 0x789a(%rip), %rax      # 0xbb30
cmpq (%rax), %rbx
je 0x42c3
leaq 0x76d6(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2340
movq %rbx, %rdi
xorl %eax, %eax
callq 0x587d
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x56e6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x76c8(%rip), %rax      # 0xb998
movl $0x0, (%rax)
cmpl $0x4, 0x2c(%rdi)
jne 0x4337
movq %rdi, %r14
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x4337
movq %rax, %rbx
movq (%rax), %rax
cmpq 0x20(%r14), %rax
jne 0x4337
leaq 0x782c(%rip), %rax      # 0xbb30
cmpq (%rax), %rbx
je 0x4337
leaq 0x7668(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2340
movq %rbx, %rdi
xorl %eax, %eax
callq 0x587d
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x56e6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x71b8(%rip), %r15      # 0xb978
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
leaq 0xc(%rsp), %r14
movq %r14, %r9
callq 0x2130
cmpl $0x0, (%r14)
je 0x489b
leaq 0x20(%rsp), %r14
xorl %r12d, %r12d
movq (%r15), %rdi
movq (%rsp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdx
callq 0x2490
cmpl $0x0, 0x98(%rsp)
jne 0x488b
movq (%rsp), %rax
movq (%rax,%r12,8), %rdi
cmpq 0x10(%rbx), %rdi
je 0x488b
movl $0x1, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x488b
movq (%rax), %rcx
movq (%rsp), %rdx
cmpq (%rdx,%r12,8), %rcx
jne 0x488b
cmpl $0x0, 0x9c(%rax)
jne 0x488b
movl 0x20(%rsp), %ecx
movl %ecx, 0x28(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x2c(%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x30(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x34(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x38(%rax)
movq %rbx, 0xf8(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x2, 0x7c(%rsp)
jne 0x488b
movq %rax, %rdi
movl $0x1, %esi
callq 0x4340
incq %r12
movl 0xc(%rsp), %eax
cmpq %rax, %r12
jb 0x47f3
movq (%rsp), %rdi
callq 0x2170
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x707d(%rip), %r14      # 0xb978
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2420
movq %rbx, %rdi
movl $0x1, %esi
callq 0x49a1
movq (%r14), %rdi
movq (%rbx), %rsi
movq 0xf8(%rbx), %rax
movq 0x8(%rax), %rdx
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %r8d
callq 0x2050
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x49a1
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x23d0
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movl %ebp, 0x98(%rbx)
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0x703c(%rip), %rcx      # 0xb9a0
movq (%rcx), %rcx
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x2360
addq $0x10, %rsp
leaq 0x71e2(%rip), %rbx      # 0xbb68
movl $0x1, (%rbx)
movq (%r14), %rdi
xorl %esi, %esi
callq 0x23a0
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rax
testq %rax, %rax
je 0x4ac5
movq %rax, %rbx
movl 0xe0(%rax), %r14d
testq %r14, %r14
jne 0x4a80
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4aca
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
testq %rax, %rax
je 0x4aca
cmpl $0x0, 0xe0(%rax)
jne 0x4a4a
jmp 0x4aca
testl %r14d, %r14d
jle 0x4aca
incq %r14
xorl %ebp, %ebp
movq 0xf0(%rbx), %rax
movq 0xf8(%rbx), %rdi
movq -0x10(%rax,%r14,8), %rsi
callq 0x4ade
movq 0xe8(%rbx), %rax
movq -0x10(%rax,%r14,8), %rax
xorl %ecx, %ecx
cmpq (%rbx), %rax
sete %cl
addl %ecx, %ebp
decq %r14
cmpq $0x1, %r14
jg 0x4a8a
testl %ebp, %ebp
je 0x4aca
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd8(%rbx), %rsi
movq 0xf8(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4ade
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x9c(%rdi)
jne 0x4b55
leaq 0x6e41(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq (%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x2490
movq 0x50(%r14), %rax
movq %rax, 0xd8(%rbx)
movq (%rbx), %rdi
leaq 0x6e69(%rip), %rax      # 0xb9c8
movq (%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x21, %edx
movl $0x64, %ecx
callq 0x4cdb
movl %eax, %ebp
cmpl $0x0, 0xe0(%rbx)
je 0x4b99
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
testl %ebp, %ebp
jle 0x4c30
movl %ebp, 0xe0(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0xe8(%rbx)
movl %ebp, %r15d
leaq (,%r15,8), %rdi
callq 0x2330
movq %rax, 0xf0(%rbx)
leaq 0xd8(%rbx), %r13
xorl %ebp, %ebp
leaq 0x6d9e(%rip), %r12      # 0xb978
leaq 0x10(%rsp), %r14
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rsi
movq %r13, %rax
cmpq (%rbx), %rsi
je 0x4c18
movq (%r12), %rdi
movl $0x800000, %edx         # imm = 0x800000
callq 0x23b0
movq (%r12), %rdi
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdx
callq 0x2490
leaq 0x60(%rsp), %rax
movq (%rax), %rax
movq 0xf0(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0x4bdf
jmp 0x4c3a
movl $0x0, 0xe0(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xd0(%rdi), %rcx
testq %rcx, %rcx
jne 0x4c8d
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
jne 0x4c8d
movq 0xb8(%rbx), %rcx
testq %rcx, %rcx
jne 0x4c8d
movq 0xc0(%rbx), %rax
testq %rax, %rax
leaq 0x2994(%rip), %rcx      # 0x761d
cmovneq %rax, %rcx
leaq 0x2992(%rip), %r15      # 0x7626
movq %rcx, %r14
movq %rcx, %rdi
movq %r15, %rsi
callq 0x25e0
leaq 0x3(%rax), %rcx
testq %rax, %rax
jne 0x4c94
movq %r14, %rdi
movl $0x3a, %esi
callq 0x2160
testq %rax, %rax
je 0x4cc0
movb $0x0, (%rax)
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x4cc3
movq %r14, 0xb0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r8
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x6c7e(%rip), %rcx      # 0xb978
movq (%rcx), %rdi
leaq 0x10(%rsp), %r10
movq %rsp, %r11
leaq 0xc(%rsp), %r14
leaq 0x18(%rsp), %r15
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rbx
pushq %r10
pushq %r11
pushq %r14
pushq %r15
pushq %rax
callq 0x2550
addq $0x30, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x4d49
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4d49
cmpq $0x0, (%rsp)
jne 0x4d46
callq 0x2170
movl (%rsp), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
movslq %esi, %rax
movq %rsp, %r10
movq %rax, (%r10)
movq $0x0, 0x8(%r10)
movl %eax, 0x98(%rdi)
leaq 0x6b93(%rip), %rax      # 0xb978
movq (%rax), %rax
movq (%rdi), %rsi
leaq 0x6bae(%rip), %rcx      # 0xb9a0
movq (%rcx), %rcx
movq %rax, %rdi
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %r10
callq 0x2360
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
leaq 0x6b73(%rip), %rax      # 0xb9a0
movq (%rax), %rdx
movl $0x2, %ecx
movq %rdx, %rsi
callq 0x4cdb
testl %eax, %eax
jle 0x4e56
movq 0x8(%rsp), %rdi
movl (%rdi), %eax
movl %eax, (%rbx)
callq 0x2170
movl $0x1, %eax
jmp 0x4e58
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x0, 0xa8(%rbx)
leaq 0x6b36(%rip), %rax      # 0xb9b0
movq (%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x4, %edx
movl $0x14, %ecx
callq 0x4cdb
testl %eax, %eax
jle 0x4ee5
movq 0x8(%rsp), %rcx
leaq 0x6b17(%rip), %rdx      # 0xb9b8
movq (%rdx), %rdx
leaq 0x6b15(%rip), %rsi      # 0xb9c0
movq (%rsi), %rsi
movl %eax, %eax
xorl %edi, %edi
movq (%rcx,%rdi,8), %r9
movl $0x1, %r8d
cmpq %rdx, %r9
je 0x4ecc
movl $0x2, %r8d
cmpq %rsi, %r9
jne 0x4ed3
orl %r8d, 0xa8(%rbx)
incq %rdi
cmpq %rdi, %rax
jne 0x4eb2
movq 0x8(%rsp), %rdi
callq 0x2170
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25d0
testl %eax, %eax
je 0x5143
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x682e(%rip), %rax      # 0xb978
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x2210
cmpb $0x0, 0x78(%r14)
je 0x5168
addq $0x78, %r14
movq %r14, %rdi
callq 0x2250
testq %rbx, %rbx
je 0x5175
movq %rbx, %rdi
callq 0x28d2
leaq 0x24fc(%rip), %rdi      # 0x7678
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2570
leaq 0x24ef(%rip), %rdi      # 0x767e
callq 0x24a0
movl $0x1, %edi
callq 0x2520
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x523f
movq %rdi, %rbx
movl 0x30(%rdi), %r14d
movl 0x34(%rdi), %ebp
xorl %eax, %eax
callq 0x67ce
testl %eax, %eax
je 0x523f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x56e6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x587d
leaq 0x6799(%rip), %r15      # 0xb978
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
callq 0x2580
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x6124(%rip), %r12      # 0xb320
movl (%r12), %eax
subl %eax, %edx
movl 0x2c(%rbx), %ecx
subl %eax, %ecx
leal -0x2(,%rax,2), %r9d
movl 0x30(%rbx), %r8d
addl %r9d, %r8d
addl 0x34(%rbx), %r9d
callq 0x21a0
movl 0x30(%rbx), %r8d
cmpl %r14d, %r8d
jne 0x5248
cmpl %ebp, 0x34(%rbx)
jne 0x5248
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x353c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq (%rbx), %rsi
movl (%r12), %ecx
decl %ecx
movl 0x34(%rbx), %r9d
movl %ecx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x52d5
movq %rdi, %rbx
xorl %eax, %eax
callq 0x68f9
testl %eax, %eax
je 0x52d5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x56e6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x587d
leaq 0x66df(%rip), %r14      # 0xb978
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2580
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x606a(%rip), %rax      # 0xb320
movl (%rax), %eax
subl %eax, %edx
movl 0x2c(%rbx), %ecx
subl %eax, %ecx
callq 0x2180
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x353c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5311
testl %esi, %esi
jne 0x5312
movl 0xa8(%rdi), %eax
andl $0x1, %eax
je 0x5312
movq (%rdi), %rdi
leaq 0x66b5(%rip), %rax      # 0xb9b0
movq (%rax), %rsi
leaq 0x66b3(%rip), %rax      # 0xb9b8
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x34af
retq
leaq 0x665f(%rip), %rax      # 0xb978
movq (%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x53f2
cmpl $0x20, 0x66e9(%rip)     # 0xba20
je 0x53f2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, 0x98(%rdi)
je 0x53f3
leaq 0x6620(%rip), %r14      # 0xb978
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2420
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2420
movq %rbx, %rdi
movl $0x3, %esi
xorl %eax, %eax
callq 0x4dc3
leaq 0x67ab(%rip), %rax      # 0xbb30
cmpq %rbx, (%rax)
jne 0x5391
xorl %eax, %eax
callq 0x5785
movslq 0x6688(%rip), %rax      # 0xba20
testq %rax, %rax
jle 0x53ce
leaq 0x668c(%rip), %rcx      # 0xba30
leaq 0x5fd5(%rip), %rdx      # 0xb380
movq %rax, %rsi
movq -0x8(%rcx,%rsi,8), %rdi
movq %rdi, (%rcx,%rsi,8)
movq 0x20(%rdx,%rsi,8), %rdi
movq %rdi, 0x28(%rdx,%rsi,8)
leaq -0x1(%rsi), %rdi
cmpq $0x1, %rsi
movq %rdi, %rsi
jg 0x53ae
movq %rbx, 0x665b(%rip)      # 0xba30
movq 0xb0(%rbx), %rcx
movq %rcx, 0x5fc5(%rip)      # 0xb3a8
incl %eax
movl %eax, 0x6635(%rip)      # 0xba20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x291c
jmp 0x53eb
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
movl 0x6612(%rip), %ecx      # 0xba20
cmpl %edi, %ecx
jle 0x54c8
movslq %ebx, %r12
leaq 0x6610(%rip), %r15      # 0xba30
movq (%r15,%r12,8), %r14
cmpl $0x3, 0x98(%r14)
jne 0x54eb
testl %esi, %esi
je 0x5479
leaq 0x653b(%rip), %r13      # 0xb978
movq (%r13), %rdi
movq (%r14), %rsi
callq 0x24c0
movq (%r13), %rdi
movq 0x8(%r14), %rsi
callq 0x2340
movq %r14, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x4dc3
movq %r14, %rdi
xorl %eax, %eax
callq 0x56e6
movq %r14, %rdi
xorl %eax, %eax
callq 0x587d
movslq 0x65a0(%rip), %rax      # 0xba20
leaq -0x1(%rax), %rcx
movl %ecx, 0x6596(%rip)      # 0xba20
leaq 0x5eef(%rip), %rdx      # 0xb380
cmpl %ebx, %ecx
jle 0x54b5
movq 0x8(%r15,%r12,8), %rsi
movq %rsi, (%r15,%r12,8)
movq 0x30(%rdx,%r12,8), %rsi
movq %rsi, 0x28(%rdx,%r12,8)
leaq 0x1(%r12), %rsi
movq %rsi, %r12
cmpq %rsi, %rcx
jne 0x5495
movq $0x0, 0x20(%rdx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x5b29(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x21d5(%rip), %rsi      # 0x76ae
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22b0
movq %r14, %rdi
callq 0x293e
jmp 0x54be
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movslq 0x6523(%rip), %rcx      # 0xba20
testq %rcx, %rcx
jle 0x551c
leaq 0x6527(%rip), %rdx      # 0xba30
xorl %eax, %eax
cmpq %rdi, (%rdx)
je 0x5523
incq %rax
addq $0x8, %rdx
cmpq %rax, %rcx
jne 0x550b
callq 0x2962
popq %rax
retq
movl %eax, %edi
popq %rax
jmp 0x53fd
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
leaq 0x21e0(%rip), %rax      # 0x7715
cmovneq %rsi, %rax
movq %rax, 0xb0(%rdi)
cmpl $0x3, 0x98(%rdi)
jne 0x5571
movslq 0x64d0(%rip), %rcx      # 0xba20
testq %rcx, %rcx
jle 0x5571
shlq $0x3, %rcx
xorl %edx, %edx
leaq 0x64ce(%rip), %rsi      # 0xba30
cmpq %rdi, (%rdx,%rsi)
je 0x5572
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x5562
retq
leaq 0x5e07(%rip), %rcx      # 0xb380
movq %rax, 0x28(%rdx,%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rcx
movq 0xf8(%rdi), %rax
cmpq 0x8(%rax), %rcx
jne 0x5592
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x63cf(%rip), %r15      # 0xb978
movq (%r15), %rdi
testl %esi, %esi
je 0x5612
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x20d0
movq (%r15), %r15
movq (%r14), %r12
xorl %eax, %eax
callq 0x3433
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x25c0
testb $0x2, 0xa8(%r14)
je 0x5606
movq (%r14), %rdi
leaq 0x63c0(%rip), %rax      # 0xb9b0
movq (%rax), %rsi
leaq 0x63c6(%rip), %rax      # 0xb9c0
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x34af
movq %r14, %rdi
xorl %eax, %eax
callq 0x4a43
jmp 0x563e
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x21c0
movq %r14, %rdi
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5653
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x6311(%rip), %r14      # 0xb978
movq (%r14), %rdi
xorl %eax, %eax
testl %esi, %esi
sete %al
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rcx
movq 0x38(%rcx,%rax,8), %rdx
callq 0x24f0
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2090
testl %ebp, %ebp
je 0x56dd
cmpl $0x0, 0xa4(%rbx)
je 0x56dd
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
movq 0x20(%rax), %rdx
leaq 0x5c6c(%rip), %rax      # 0xb324
movl (%rax), %ecx
movl 0x30(%rbx), %r9d
leaq 0x5c5b(%rip), %rax      # 0xb320
movl (%rax), %eax
subl %ecx, %r9d
addl %eax, %r9d
subl %ecx, %eax
addl 0x34(%rbx), %eax
movl %eax, (%rsp)
movl %ecx, %r8d
callq 0x20b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdi, %rdi
je 0x577e
movq %rdi, %rbx
movq 0x6436(%rip), %rdi      # 0xbb30
cmpq %rbx, %rdi
je 0x577c
testq %rdi, %rdi
je 0x5729
xorl %esi, %esi
callq 0x5580
movq 0x641e(%rip), %rax      # 0xbb30
movq 0xf8(%rax), %rdi
cmpq 0xf8(%rbx), %rdi
je 0x5729
xorl %eax, %eax
callq 0x4afd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5580
movq 0x63fb(%rip), %rax      # 0xbb38
testq %rax, %rax
je 0x5756
cmpq %rbx, 0x20(%rax)
jne 0x5750
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rax), %rax
jmp 0x573d
movq 0x63d3(%rip), %rax      # 0xbb30
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x5775
cmpl $0x1, 0x98(%rax)
je 0x5775
movq 0x20(%rax), %rax
jmp 0x575d
movq %rbx, 0x63b4(%rip)      # 0xbb30
popq %rbx
retq
callq 0x2986
jmp 0x577c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x78, %rsp
movq 0x639d(%rip), %rdi      # 0xbb30
testq %rdi, %rdi
je 0x57d5
xorl %esi, %esi
callq 0x5580
movq 0x638a(%rip), %rax      # 0xbb30
movq %rax, %rdi
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x57c7
cmpl $0x1, 0x98(%rdi)
jne 0x57a9
addq $0x78, %rsp
popq %rbx
popq %r14
jmp 0x56e6
movq 0xf8(%rax), %rdi
xorl %eax, %eax
callq 0x4afd
movq $0x0, 0x6350(%rip) # 0xbb30
cmpq $0x0, 0x6358(%rip)      # 0xbb40
jne 0x584a
leaq 0x8(%rsp), %rax
movl $0x1, 0x58(%rax)
leaq 0x617b(%rip), %rbx      # 0xb978
movq (%rbx), %rdi
leaq 0x6209(%rip), %rcx      # 0xba10
movq (%rcx), %rcx
movq 0x8(%rcx), %rsi
xorl %r10d, %r10d
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq $0x200                  # imm = 0x200
pushq $0x0
pushq $0x2
pushq %r10
pushq %r10
callq 0x2380
addq $0x30, %rsp
movq %rax, 0x6301(%rip)      # 0xbb40
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x24c0
leaq 0x6127(%rip), %rax      # 0xb978
movq (%rax), %rbx
movq 0x62e5(%rip), %r14      # 0xbb40
xorl %eax, %eax
callq 0x3433
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x25c0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rdx
movq 0x62b1(%rip), %rcx      # 0xbb38
testq %rcx, %rcx
je 0x58c9
cmpq %rdx, %rcx
je 0x58a8
movq %rcx, %rax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x58c9
cmpq %rdx, %rcx
jne 0x5891
addq $0x18, %rax
jmp 0x58af
leaq 0x6289(%rip), %rax      # 0xbb38
movq 0x18(%rdx), %rcx
movq %rcx, (%rax)
movq 0x627b(%rip), %rax      # 0xbb38
movq %rax, 0x18(%rdx)
movq %rdx, 0x6270(%rip)      # 0xbb38
retq
movq 0x5728(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x1e52(%rip), %rsi      # 0x772c
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x599b
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x340c
testq %rax, %rax
jne 0x599d
movq 0x6229(%rip), %rbx      # 0xbb38
testq %rbx, %rbx
je 0x5929
cmpq %r14, (%rbx)
je 0x599d
cmpq %r14, 0x8(%rbx)
je 0x599d
movq 0x18(%rbx), %rbx
jmp 0x590f
testl %ebp, %ebp
je 0x599b
movl $0x100, %edi            # imm = 0x100
callq 0x2330
movq %rax, %rbx
xorl %r15d, %r15d
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
xorl %esi, %esi
callq 0x21d0
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %r15, 0xd8(%rbx)
movq %r15, 0xc0(%rbx)
movq %r15, 0xb0(%rbx)
movq %r15, 0x20(%rbx)
movl $0x0, 0xe0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xe8(%rbx)
movq 0x61aa(%rip), %rax      # 0xbb38
movq %rax, 0x18(%rbx)
movq %rbx, 0x619f(%rip)      # 0xbb38
jmp 0x599d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/client.c
// Function: rmclient
void
rmclient(Client * c)
{
	Client *cc;

	for (cc = current; cc && cc->revert; cc = cc->revert)
		if (cc->revert == c)
			cc->revert = cc->revert->revert;

	if (c == clients)
		clients = c->next;
	for (cc = clients; cc && cc->next; cc = cc->next)
		if (cc->next == c)
			cc->next = cc->next->next;

	if (hidden(c))
		unhidec(c, 0);

	if (c->parent != c->screen->root)
		XDestroyWindow(dpy, c->parent);

	c->parent = c->window = None;	/* paranoia */
	if (current == c) {
		current = c->revert;
		if (current == 0)
			nofocus();
		else {
			if (current->screen != c->screen)
				cmapnofocus(c->screen);
			setactive(current, 1);
		}
	}
	if (c->ncmapwins != 0) {
		XFree((char *) c->cmapwins);
		free((char *) c->wmcmaps);
	}
	if (c->iconname != 0)
		XFree((char *) c->iconname);
	if (c->name != 0)
		XFree((char *) c->name);
	if (c->instance != 0)
		XFree((char *) c->instance);
	if (c->class != 0)
		XFree((char *) c->class);
	memset(c, 0, sizeof(Client));	/* paranoia */
	free(c);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x617a(%rip), %rax      # 0xbb30
testq %rax, %rax
je 0x59d7
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x59d7
cmpq %rbx, %rcx
jne 0x59d1
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rax
jmp 0x59b6
cmpq %rbx, 0x615a(%rip)      # 0xbb38
jne 0x59eb
movq 0x18(%rbx), %rax
movq %rax, 0x614d(%rip)      # 0xbb38
movq 0x6146(%rip), %rax      # 0xbb38
testq %rax, %rax
je 0x5a13
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x5a13
cmpq %rbx, %rcx
jne 0x5a0d
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rax
jmp 0x59f2
cmpl $0x3, 0x98(%rbx)
jne 0x5a28
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x54f5
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
cmpq 0x8(%rax), %rsi
je 0x5a48
leaq 0x5f38(%rip), %rax      # 0xb978
movq (%rax), %rdi
callq 0x2260
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpq %rbx, 0x60db(%rip)      # 0xbb30
jne 0x5a96
movq 0x20(%rbx), %rax
movq %rax, 0x60ce(%rip)      # 0xbb30
testq %rax, %rax
je 0x5a91
movq 0xf8(%rbx), %rdi
cmpq %rdi, 0xf8(%rax)
je 0x5a7e
xorl %eax, %eax
callq 0x4afd
movq 0x60ab(%rip), %rdi      # 0xbb30
movl $0x1, %esi
callq 0x5580
jmp 0x5a96
callq 0x5785
cmpl $0x0, 0xe0(%rbx)
je 0x5ab7
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5ac8
callq 0x2170
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x5ad9
callq 0x2170
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x5aea
callq 0x2170
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x5afb
callq 0x2170
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21d0
movq %rbx, %rdi
popq %rbx
jmp 0x2080
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testl %r8d, %r8d
jne 0x5b4f
xorl %eax, %eax
callq 0x3433
movq %rax, %r8
leaq 0x5e22(%rip), %rax      # 0xb978
movq (%rax), %rdi
movslq %r8d, %rax
subq $0x8, %rsp
movq %r15, %rsi
xorl %edx, %edx
movl %ebp, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r14
pushq %rbx
callq 0x2200
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movb $0x1, %al
cmpl $0x5, (%rdi)
jne 0x5bae
movl $0x1f00, %eax           # imm = 0x1F00
andl 0x50(%rbx), %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
setne %al
testb %al, %al
je 0x5bee
leaq 0x40(%rsp), %rbx
leaq 0x5dba(%rip), %r15      # 0xb978
leaq 0x8(%rsp), %r14
movl $0x1f00, %ebp           # imm = 0x1F00
movq (%r15), %rdi
movl $0x200c, %esi           # imm = 0x200C
movq %r14, %rdx
callq 0x25f0
cmpl $0x5, 0x8(%rsp)
jne 0x5bc8
movl 0x58(%rsp), %eax
andl %ebp, %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
jne 0x5bc8
jmp 0x5bf2
addq $0x38, %rbx
leaq 0x5d7f(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x22e0
movl (%rbx), %eax
leaq 0x5d8b(%rip), %rcx      # 0xb998
movl %eax, (%rcx)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: selectwin
Client *
selectwin(int release, int *shift, ScreenInfo * s)
{
	XEvent ev;
	XButtonEvent *e;
	int status;
	Window w;
	Client *c;

	status = grab(s->root, s->root, ButtonMask, s->target, 0);
	if (status != GrabSuccess) {
		graberror("selectwin", status);	/* */
		return 0;
	}
	w = None;
	for (;;) {
		XMaskEvent(dpy, ButtonMask, &ev);
		e = &ev.xbutton;
		switch (ev.type) {
		case ButtonPress:
			if (e->button != Button3) {
				ungrab(e);
				return 0;
			}
			w = e->subwindow;
			if (!release) {
				c = getclient(w, 0);
				if (c == 0)
					ungrab(e);
				if (shift != 0)
					*shift = (e->state & ShiftMask) != 0;
				return c;
			}
			break;
		case ButtonRelease:
			ungrab(e);
			if (e->button != Button3 || e->subwindow != w)
				return 0;
			if (shift != 0)
				*shift = (e->state & ShiftMask) != 0;
			return getclient(w, 0);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rdx), %r14
movq 0x50(%rdx), %r15
xorl %eax, %eax
callq 0x3433
leaq 0x575e(%rip), %r12      # 0xb978
movq (%r12), %rdi
cltq
subq $0x8, %rsp
movq %r14, %rsi
xorl %edx, %edx
movl $0xc, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r15
pushq %r14
callq 0x2200
addq $0x20, %rsp
testl %eax, %eax
je 0x6264
leaq 0x1547(%rip), %rdi      # 0x779a
xorl %r15d, %r15d
movl %eax, %esi
xorl %eax, %eax
callq 0x6df0
jmp 0x6302
xorl %r14d, %r14d
movq %rsp, %r15
movq (%r12), %rdi
movl $0xc, %esi
movq %r15, %rdx
callq 0x25f0
movl (%rsp), %eax
cmpl $0x5, %eax
je 0x62c8
cmpl $0x4, %eax
jne 0x626a
cmpl $0x3, 0x54(%rsp)
jne 0x6315
movq 0x30(%rsp), %r14
testl %ebp, %ebp
jne 0x626a
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
movq %rax, %r15
testq %rax, %rax
jne 0x62b8
movq %rsp, %rdi
callq 0x5b87
testq %rbx, %rbx
je 0x6302
movl 0x50(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
jmp 0x6302
movq %rsp, %r12
movq %r12, %rdi
callq 0x5b87
xorl %r15d, %r15d
cmpl $0x3, 0x54(%r12)
jne 0x6302
cmpq %r14, 0x30(%rsp)
jne 0x6302
testq %rbx, %rbx
je 0x62f3
movl 0x50(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58e1
movq %rax, %r15
movq %r15, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
callq 0x5b87
xorl %r15d, %r15d
jmp 0x6302
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: sweepcalc
void
sweepcalc(Client * c, int x, int y)
{
	int dx, dy, sx, sy;

	dx = x - c->x;
	dy = y - c->y;
	sx = sy = 1;
	if (dx < 0) {
		dx = -dx;
		sx = -1;
	}
	if (dy < 0) {
		dy = -dy;
		sy = -1;
	}

	dx -= 2 * BORDER;
	dy -= 2 * BORDER;
	if (c->size.flags & PResizeInc) {
		dx = c->min_dx + (dx - c->min_dx) / c->size.width_inc * c->size.width_inc;
		dy = c->min_dy + (dy - c->min_dy) / c->size.height_inc * c->size.height_inc;
	}

	if (c->size.flags & PMaxSize) {
		if (dx > c->size.max_width)
			dx = c->size.max_width;
		if (dy > c->size.max_height)
			dy = c->size.max_height;
	}
	c->dx = sx * (dx + 2 * BORDER);
	c->dy = sy * (dy + 2 * BORDER);
}

// Assembly:
movl %edx, %ecx
subl 0x28(%rdi), %esi
subl 0x2c(%rdi), %ecx
movl %esi, %r9d
negl %r9d
cmovsl %esi, %r9d
movl %ecx, %r8d
negl %r8d
cmovsl %ecx, %r8d
leaq 0x4fdb(%rip), %rax      # 0xb320
movl (%rax), %r10d
addl %r10d, %r10d
subl %r10d, %r9d
subl %r10d, %r8d
movq 0x40(%rdi), %r11
testb $0x40, %r11b
je 0x637f
pushq %rbx
movl 0x94(%rdi), %ebx
movl %r9d, %eax
subl 0x90(%rdi), %eax
cltd
idivl 0x68(%rdi)
subl %edx, %r9d
movl %r8d, %eax
subl %ebx, %eax
cltd
idivl 0x6c(%rdi)
subl %edx, %r8d
popq %rbx
testb $0x20, %r11b
je 0x6399
movl 0x60(%rdi), %eax
cmpl %eax, %r9d
cmovgel %eax, %r9d
movl 0x64(%rdi), %eax
cmpl %eax, %r8d
cmovgel %eax, %r8d
addl %r10d, %r9d
movl %r9d, %eax
negl %eax
testl %esi, %esi
cmovnsl %r9d, %eax
movl %eax, 0x30(%rdi)
addl %r10d, %r8d
movl %r8d, %eax
negl %eax
testl %ecx, %ecx
cmovnsl %r8d, %eax
movl %eax, 0x34(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: drawbound
void
drawbound(Client * c)
{
	int x, y, dx, dy;
	ScreenInfo *s;

	s = c->screen;
	x = c->x;
	y = c->y;
	dx = c->dx;
	dy = c->dy;
	if (dx < 0) {
		x += dx;
		dx = -dx;
	}
	if (dy < 0) {
		y += dy;
		dy = -dy;
	}
	if (dx <= 2 || dy <= 2)
		return;
	XDrawRectangle(dpy, s->root, s->gc, x, y, dx - 1, dy - 1);
	XDrawRectangle(dpy, s->root, s->gc, x + 1, y + 1, dx - 3, dy - 3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x30(%rdi), %eax
movl 0x34(%rdi), %ecx
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
movl %ecx, %r14d
negl %r14d
cmovsl %ecx, %r14d
cmpl $0x3, %ebx
setb %dl
cmpl $0x3, %r14d
setb %sil
orb %dl, %sil
jne 0x6484
movl 0x28(%rdi), %r13d
movl 0x2c(%rdi), %edx
movq %rdx, 0x10(%rsp)
movl %ecx, %r12d
sarl $0x1f, %r12d
andl %ecx, %r12d
leal (%rdx,%r12), %r8d
movl %eax, %ebp
sarl $0x1f, %ebp
andl %eax, %ebp
leal (%r13,%rbp), %ecx
movq 0xf8(%rdi), %r15
leaq 0x5545(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%r15), %rsi
movq 0x20(%r15), %rdx
leal -0x1(%rbx), %r9d
leal -0x1(%r14), %eax
movl %eax, (%rsp)
callq 0x20b0
leaq 0x5523(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%r15), %rsi
movq 0x20(%r15), %rdx
leal 0x1(%r13,%rbp), %ecx
movq 0x10(%rsp), %rax
leal (%rax,%r12), %r8d
incl %r8d
addl $-0x3, %ebx
addl $-0x3, %r14d
movl %r14d, (%rsp)
movl %ebx, %r9d
callq 0x20b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: misleep
void
misleep(int msec)
{
	struct timeval t;

	t.tv_sec = msec / 1000;
	t.tv_usec = (msec % 1000) * 1000;
	select(0, 0, 0, 0, &t);
}

// Assembly:
subq $0x18, %rsp
movslq %edi, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
leaq 0x8(%rsp), %r8
movq %rcx, (%r8)
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
cltq
movq %rax, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: sweep
int
sweep(Client * c)
{
	XEvent ev;
	int status;
	XButtonEvent *e;
	ScreenInfo *s;

	s = c->screen;
	status = grab(s->root, s->root, ButtonMask, s->sweep0, 0);
	if (status != GrabSuccess) {
		graberror("sweep", status);	/* */
		return 0;
	}

	XMaskEvent(dpy, ButtonMask, &ev);
	e = &ev.xbutton;
	if (e->button != Button3) {
		ungrab(e);
		return 0;
	}
	if (c->size.flags & (PMinSize | PBaseSize))
		setmouse(e->x + c->min_dx, e->y + c->min_dy, s);
	XChangeActivePointerGrab(dpy, ButtonMask, s->boxcurs, e->time);
	return sweepdrag(c, e, sweepcalc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
movq 0x8(%r15), %r14
movq 0x58(%r15), %r13
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3433
leaq 0x5177(%rip), %r12      # 0xb978
movq (%r12), %rdi
cltq
subq $0x8, %rsp
movq %r14, %rsi
xorl %edx, %edx
movl $0xc, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r13
pushq %r14
callq 0x2200
addq $0x20, %rsp
testl %eax, %eax
je 0x6848
leaq 0xf6a(%rip), %rdi       # 0x77a4
movl %eax, %esi
xorl %eax, %eax
callq 0x6df0
jmp 0x68e5
movq (%r12), %rdi
leaq 0x8(%rsp), %r14
movl $0xc, %esi
movq %r14, %rdx
callq 0x25f0
cmpl $0x3, 0x54(%r14)
jne 0x68db
movzwl 0x40(%rbx), %eax
testl $0x110, %eax            # imm = 0x110
je 0x68aa
movl 0x90(%rbx), %eax
movl 0x94(%rbx), %r10d
addl 0x48(%rsp), %eax
addl 0x4c(%rsp), %r10d
movq (%r12), %rdi
movq 0x8(%r15), %rdx
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x2230
addq $0x20, %rsp
movq (%r12), %rdi
movq 0x60(%r15), %rdx
leaq 0x8(%rsp), %r14
movq 0x38(%r14), %rcx
movl $0xc, %esi
callq 0x25b0
leaq -0x5aa(%rip), %rdx      # 0x6322
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64df
movl %eax, %ebp
jmp 0x68e5
leaq 0x8(%rsp), %rdi
callq 0x5b87
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/9wm[P]9wm/grab.c
// Function: drag
int
drag(Client * c)
{
	int status;
	ScreenInfo *s;

	s = c->screen;
	if (c->init)
		setmouse(c->x - BORDER, c->y - BORDER, s);
	else {
		getmouse(&c->x, &c->y, s);	/* start at current mouse pos */
		c->x += BORDER;
		c->y += BORDER;
	}
	status = grab(s->root, s->root, ButtonMask, s->boxcurs, 0);
	if (status != GrabSuccess) {
		graberror("drag", status);	/* */
		return 0;
	}
	return sweepdrag(c, 0, dragcalc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
cmpl $0x0, 0x9c(%rdi)
je 0x695a
leaq 0x4a03(%rip), %rax      # 0xb320
movl (%rax), %eax
movl 0x28(%rbx), %r10d
movl 0x2c(%rbx), %r11d
subl %eax, %r10d
subl %eax, %r11d
leaq 0x5044(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%r15), %rdx
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r11
pushq %r10
pushq $0x0
callq 0x2230
addq $0x20, %rsp
jmp 0x69aa
leaq 0x28(%rbx), %r8
leaq 0x2c(%rbx), %r9
leaq 0x500f(%rip), %rax      # 0xb978
movq (%rax), %rdi
movq 0x8(%r15), %rsi
subq $0x8, %rsp
leaq 0x14(%rsp), %rax
leaq 0x18(%rsp), %r10
leaq 0x1c(%rsp), %r11
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
pushq %rax
pushq %r10
pushq %r11
callq 0x22c0
addq $0x20, %rsp
leaq 0x497e(%rip), %rax      # 0xb320
movl (%rax), %eax
addl %eax, 0x28(%rbx)
addl %eax, 0x2c(%rbx)
movq 0x8(%r15), %r14
movq 0x60(%r15), %r15
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3433
leaq 0x4fb6(%rip), %rcx      # 0xb978
movq (%rcx), %rdi
cltq
subq $0x8, %rsp
movq %r14, %rsi
xorl %edx, %edx
movl $0xc, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r15
pushq %r14
callq 0x2200
addq $0x20, %rsp
testl %eax, %eax
je 0x6a05
leaq 0xdb0(%rip), %rdi       # 0x77aa
movl %eax, %esi
xorl %eax, %eax
callq 0x6df0
jmp 0x6a18
leaq -0x650(%rip), %rdx      # 0x63bc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64df
movl %eax, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq