LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/9wm[P]9wm/event.c
// Function: property
void
property(XPropertyEvent * e)
{
	Atom a;
	int delete;
	Client *c;

	/*
	 * we don't set curtime as nothing here uses it 
	 */
	a = e->atom;
	delete = (e->state == PropertyDelete);
	c = getclient(e->window, 0);
	if (c == 0)
		return;

	switch (a) {
	case XA_WM_ICON_NAME:
		if (c->iconname != 0)
			XFree((char *) c->iconname);
		c->iconname = delete ? 0 : getprop(c->window, a);
		setlabel(c);
		renamec(c, c->label);
		return;
	case XA_WM_NAME:
		if (c->name != 0)
			XFree((char *) c->name);
		c->name = delete ? 0 : getprop(c->window, a);
		setlabel(c);
		renamec(c, c->label);
		return;
	case XA_WM_TRANSIENT_FOR:
		gettrans(c);
		return;
	}
	if (a == _9wm_hold_mode) {
		c->hold = getiprop(c->window, _9wm_hold_mode);
		if (c == current)
			draw_border(c, 1);
	} else if (a == wm_colormaps) {
		getcmaps(c);
		if (c == current)
			cmapfocus(c);
	} else if (a == wm_protocols) {
		getproto(c);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %r14
movl 0x38(%rdi), %ebp
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x4108
movq %rax, %rbx
cmpq $0x44, %r14
je 0x401d
cmpq $0x27, %r14
je 0x4003
cmpq $0x25, %r14
jne 0x402b
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x3ff3
callq 0x2170
cmpl $0x1, %ebp
jne 0x4089
xorl %eax, %eax
jmp 0x4098
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x4014
callq 0x2170
cmpl $0x1, %ebp
jne 0x4071
xorl %eax, %eax
jmp 0x4080
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4874
leaq 0x79de(%rip), %rax      # 0xba10
cmpq (%rax), %r14
jne 0x40be
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4da3
movl %eax, 0xa4(%rbx)
leaq 0x7aeb(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
jne 0x4108
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x563a
movq (%rbx), %rdi
movl $0x27, %esi
xorl %eax, %eax
callq 0x4d3d
movq %rax, 0xc8(%rbx)
jmp 0x409f
movq (%rbx), %rdi
movl $0x25, %esi
xorl %eax, %eax
callq 0x4d3d
movq %rax, 0xd0(%rbx)
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c31
movq 0xb0(%rbx), %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5513
leaq 0x7913(%rip), %rax      # 0xb9d8
cmpq (%rax), %r14
jne 0x40ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4afb
leaq 0x7a65(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
jne 0x4108
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4a0e
leaq 0x78cb(%rip), %rax      # 0xb9c0
cmpq (%rax), %r14
jne 0x4108
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4e48
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3381
testq %rax, %rax
je 0x4133
cmpl $0x0, 0x40(%r14)
je 0x4140
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x30(%r14), %rdi
xorl %eax, %eax
callq 0x3381
movq 0x28(%r14), %rdi
testq %rax, %rax
je 0x41bc
movq %rax, %rbx
movl $0x1, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x4133
movq %rax, %r14
cmpl $0x0, 0x30(%rax)
je 0x4178
cmpl $0x0, 0x34(%r14)
jne 0x4133
leaq 0x7809(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq (%r14), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x24a0
movaps (%r15), %xmm0
movups %xmm0, 0x28(%r14)
movl 0x10(%r15), %eax
movl %eax, 0x38(%r14)
movq %rbx, 0xf8(%r14)
cmpq $0x0, 0x8(%r14)
jne 0x4133
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x4133
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x4133
movq 0x8(%rax), %rcx
movq 0xf8(%rax), %rdx
cmpq 0x8(%rdx), %rcx
je 0x41ec
cmpl $0x0, 0x98(%rax)
jne 0x4133
movq %rax, %rdi
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5942
// File: /workspace/github_c_makefile_star2_O3/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 0x779b(%rip), %rcx      # 0xb9a8
movl %eax, (%rcx)
cmpl $0x1, 0x50(%rdi)
jne 0x4264
cmpl $0x4, 0x54(%rdi)
jne 0x4264
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x4264
movq %rax, %rbx
leaq 0x7909(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
je 0x4264
leaq 0x7745(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2350
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5866
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x56cd
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7737(%rip), %rax      # 0xb9a8
movl $0x0, (%rax)
cmpl $0x4, 0x2c(%rdi)
jne 0x42d8
movq %rdi, %r14
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x42d8
movq %rax, %rbx
movq (%rax), %rax
cmpq 0x20(%r14), %rax
jne 0x42d8
leaq 0x789b(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
je 0x42d8
leaq 0x76d7(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2350
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5866
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x56cd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x71f4(%rip), %r15      # 0xb988
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 0x485c
leaq 0x20(%rsp), %r14
xorl %r12d, %r12d
movq (%r15), %rdi
movq (%rsp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdx
callq 0x24a0
cmpl $0x0, 0x98(%rsp)
jne 0x484c
movq (%rsp), %rax
movq (%rax,%r12,8), %rdi
cmpq 0x10(%rbx), %rdi
je 0x484c
movl $0x1, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x484c
movq (%rax), %rcx
movq (%rsp), %rdx
cmpq (%rdx,%r12,8), %rcx
jne 0x484c
cmpl $0x0, 0x9c(%rax)
jne 0x484c
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x28(%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 0x484c
movq %rax, %rdi
movl $0x1, %esi
callq 0x42e0
incq %r12
movl 0xc(%rsp), %eax
cmpq %rax, %r12
jb 0x47c7
movq (%rsp), %rdi
callq 0x2170
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x70cc(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2430
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4962
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 0x4962
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x23e0
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movl %ebp, 0x98(%rbx)
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0x708b(%rip), %rcx      # 0xb9b0
movq (%rcx), %rcx
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x2370
addq $0x10, %rsp
leaq 0x7231(%rip), %rbx      # 0xbb78
movl $0x1, (%rbx)
movq (%r14), %rdi
xorl %esi, %esi
callq 0x23b0
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
testq %rax, %rax
je 0x4aaa
movq %rax, %rbx
movl 0xe0(%rax), %r14d
testq %r14, %r14
jne 0x4a52
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4ab5
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
testq %rax, %rax
je 0x4ab5
cmpl $0x0, 0xe0(%rax)
jne 0x4a18
jmp 0x4ab5
testl %r14d, %r14d
jle 0x4ab5
incq %r14
xorl %ebp, %ebp
leaq 0x6f25(%rip), %r15      # 0xb988
movq 0xf0(%rbx), %rax
movq -0x10(%rax,%r14,8), %rsi
testq %rsi, %rsi
jne 0x4a7f
movq 0xf8(%rbx), %rax
movq 0x18(%rax), %rsi
movq (%r15), %rdi
callq 0x2570
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
ja 0x4a63
testl %ebp, %ebp
je 0x4ab5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8(%rbx), %rsi
leaq 0x6ec5(%rip), %rax      # 0xb988
movq (%rax), %rdi
testq %rsi, %rsi
jne 0x4ad6
movq 0xf8(%rbx), %rax
movq 0x18(%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2570
// File: /workspace/github_c_makefile_star2_O3/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 0x4b3d
leaq 0x6e69(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq (%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x24a0
movq 0x50(%r14), %rax
movq %rax, 0xd8(%rbx)
movq (%rbx), %rdi
leaq 0x6e91(%rip), %rax      # 0xb9d8
movq (%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x21, %edx
movl $0x64, %ecx
callq 0x4cc0
movl %eax, %ebp
cmpl $0x0, 0xe0(%rbx)
je 0x4b81
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
testl %ebp, %ebp
jle 0x4c15
movl %ebp, 0xe0(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0xe8(%rbx)
movl %ebp, %r15d
leaq (,%r15,8), %rdi
callq 0x2340
movq %rax, 0xf0(%rbx)
xorl %r12d, %r12d
leaq 0x6dcc(%rip), %r13      # 0xb988
leaq 0x10(%rsp), %r14
movq 0x8(%rsp), %rcx
movq (%rcx,%r12,8), %rsi
cmpq (%rbx), %rsi
jne 0x4bd8
movq 0xd8(%rbx), %rcx
jmp 0x4c07
movq (%r13), %rdi
movl $0x800000, %edx         # imm = 0x800000
callq 0x23c0
movq (%r13), %rdi
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdx
callq 0x24a0
movq 0x60(%rsp), %rcx
movq 0xf0(%rbx), %rax
movq %rcx, (%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x4bc1
jmp 0x4c1f
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_O3/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 0x4c72
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
jne 0x4c72
movq 0xb8(%rbx), %rcx
testq %rcx, %rcx
jne 0x4c72
movq 0xc0(%rbx), %rax
testq %rax, %rax
leaq 0x29af(%rip), %rcx      # 0x761d
cmovneq %rax, %rcx
leaq 0x29ad(%rip), %r15      # 0x7626
movq %rcx, %r14
movq %rcx, %rdi
movq %r15, %rsi
callq 0x25f0
leaq 0x3(%rax), %rcx
testq %rax, %rax
jne 0x4c79
movq %r14, %rdi
movl $0x3a, %esi
callq 0x2160
testq %rax, %rax
je 0x4ca5
movb $0x0, (%rax)
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x4ca8
movq %r14, 0xb0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ca9(%rip), %rcx      # 0xb988
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 0x2560
addq $0x30, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x4d21
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4d17
movq (%rsp), %rax
testq %rax, %rax
jne 0x4d17
callq 0x2170
movq (%rsp), %rax
jmp 0x4d17
// File: /workspace/github_c_makefile_star2_O3/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 0x6bb9(%rip), %rax      # 0xb988
movq (%rax), %rax
movq (%rdi), %rsi
leaq 0x6bd4(%rip), %rcx      # 0xb9b0
movq (%rcx), %rcx
movq %rax, %rdi
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %r10
callq 0x2370
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6b99(%rip), %rax      # 0xb9b0
movq (%rax), %rdx
movl $0x2, %ecx
movq %rdx, %rsi
callq 0x4cc0
testl %eax, %eax
jle 0x4e40
movq 0x8(%rsp), %rdi
movl (%rdi), %eax
movl %eax, (%rbx)
callq 0x2170
movl $0x1, %eax
jmp 0x4e42
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6b5c(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
leaq 0x8(%rsp), %r8
movl $0x4, %edx
movl $0x14, %ecx
callq 0x4cc0
testl %eax, %eax
jle 0x4eca
movq 0x8(%rsp), %rdi
leaq 0x6b3d(%rip), %rcx      # 0xb9c8
movq (%rcx), %rcx
leaq 0x6b3b(%rip), %rdx      # 0xb9d0
movq (%rdx), %rdx
movl %eax, %eax
xorl %esi, %esi
movq (%rdi,%rsi,8), %r9
movl $0x1, %r8d
cmpq %rcx, %r9
je 0x4eb6
movl $0x2, %r8d
cmpq %rdx, %r9
jne 0x4ebd
orl %r8d, 0xa8(%rbx)
incq %rsi
cmpq %rsi, %rax
jne 0x4e9c
callq 0x2170
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25e0
testl %eax, %eax
je 0x5127
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x685a(%rip), %rax      # 0xb988
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x2210
cmpb $0x0, 0x78(%r14)
je 0x514c
addq $0x78, %r14
movq %r14, %rdi
callq 0x2260
testq %rbx, %rbx
je 0x5159
movq %rbx, %rdi
callq 0x2848
leaq 0x2518(%rip), %rdi      # 0x7678
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2580
leaq 0x250b(%rip), %rdi      # 0x767e
callq 0x24b0
movl $0x1, %edi
callq 0x2530
// File: /workspace/github_c_makefile_star2_O3/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 0x5227
movq %rdi, %rbx
movl 0x30(%rdi), %r14d
movl 0x34(%rdi), %ebp
xorl %eax, %eax
callq 0x6715
testl %eax, %eax
je 0x5227
movq %rbx, %rdi
xorl %eax, %eax
callq 0x56cd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5866
leaq 0x67c5(%rip), %r15      # 0xb988
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
callq 0x2590
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x6150(%rip), %r12      # 0xb330
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
movl 0x34(%rbx), %r9d
cmpl %r14d, %r8d
jne 0x5230
cmpl %ebp, %r9d
jne 0x5230
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34ad
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq (%rbx), %rsi
movl (%r12), %ecx
decl %ecx
movl %ecx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O3/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 0x52b9
movq %rdi, %rbx
xorl %eax, %eax
callq 0x6840
testl %eax, %eax
je 0x52b9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x56cd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5866
leaq 0x670b(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2590
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x6096(%rip), %rax      # 0xb330
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 0x34ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x52f5
testl %esi, %esi
jne 0x52f6
movl 0xa8(%rdi), %eax
andl $0x1, %eax
je 0x52f6
movq (%rdi), %rdi
leaq 0x66e1(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
leaq 0x66df(%rip), %rax      # 0xb9c8
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x3420
retq
leaq 0x668b(%rip), %rax      # 0xb988
movq (%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x53d6
cmpl $0x20, 0x6715(%rip)     # 0xba30
je 0x53d6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, 0x98(%rdi)
je 0x53d7
leaq 0x664c(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2430
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2430
movq %rbx, %rdi
movl $0x3, %esi
xorl %eax, %eax
callq 0x4dad
leaq 0x67d7(%rip), %rax      # 0xbb40
cmpq %rbx, (%rax)
jne 0x5375
xorl %eax, %eax
callq 0x576c
movslq 0x66b4(%rip), %rax      # 0xba30
testq %rax, %rax
jle 0x53b2
leaq 0x66b8(%rip), %rcx      # 0xba40
leaq 0x6001(%rip), %rdx      # 0xb390
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
ja 0x5392
movq %rbx, 0x6687(%rip)      # 0xba40
movq 0xb0(%rbx), %rcx
movq %rcx, 0x5ff1(%rip)      # 0xb3b8
incl %eax
movl %eax, 0x6661(%rip)      # 0xba30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2892
jmp 0x53cf
// File: /workspace/github_c_makefile_star2_O3/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 0x663e(%rip), %ecx      # 0xba30
cmpl %edi, %ecx
jle 0x54b0
movslq %ebx, %r12
leaq 0x663c(%rip), %r15      # 0xba40
movq (%r15,%r12,8), %r14
cmpl $0x3, 0x98(%r14)
jne 0x54d3
testl %esi, %esi
je 0x5463
leaq 0x6567(%rip), %r13      # 0xb988
movq (%r13), %rdi
movq (%r14), %rsi
callq 0x24d0
movq (%r13), %rdi
movq 0x8(%r14), %rsi
callq 0x2350
movq %r14, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x4dad
movq %r14, %rdi
xorl %eax, %eax
callq 0x56cd
movq %r14, %rdi
xorl %eax, %eax
callq 0x5866
movl 0x65cd(%rip), %ecx      # 0xba30
leal -0x1(%rcx), %edx
movl %edx, 0x65c4(%rip)      # 0xba30
leaq 0x5f1d(%rip), %rax      # 0xb390
cmpl %ebx, %edx
jle 0x549a
movslq %edx, %rdx
movq 0x8(%r15,%r12,8), %rsi
movq %rsi, (%r15,%r12,8)
movq 0x30(%rax,%r12,8), %rsi
movq %rsi, 0x28(%rax,%r12,8)
leaq 0x1(%r12), %rsi
movq %rsi, %r12
cmpq %rsi, %rdx
jne 0x547a
movslq %ecx, %rcx
movq $0x0, 0x20(%rax,%rcx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x5b41(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x21ed(%rip), %rsi      # 0x76ae
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22c0
movq %r14, %rdi
callq 0x28b4
jmp 0x54a6
// File: /workspace/github_c_makefile_star2_O3/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 0x654b(%rip), %rcx      # 0xba30
testq %rcx, %rcx
jle 0x5504
leaq 0x654f(%rip), %rdx      # 0xba40
xorl %eax, %eax
cmpq %rdi, (%rdx)
je 0x550b
incq %rax
addq $0x8, %rdx
cmpq %rax, %rcx
jne 0x54f3
callq 0x28d8
popq %rax
retq
movl %eax, %edi
popq %rax
jmp 0x53e1
// File: /workspace/github_c_makefile_star2_O3/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 0x21f8(%rip), %rax      # 0x7715
cmovneq %rsi, %rax
movq %rax, 0xb0(%rdi)
cmpl $0x3, 0x98(%rdi)
jne 0x5559
movslq 0x64f8(%rip), %rcx      # 0xba30
testq %rcx, %rcx
jle 0x5559
shlq $0x3, %rcx
xorl %edx, %edx
leaq 0x64f6(%rip), %rsi      # 0xba40
cmpq %rdi, (%rdx,%rsi)
je 0x555a
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x554a
retq
leaq 0x5e2f(%rip), %rcx      # 0xb390
movq %rax, 0x28(%rdx,%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x557a
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x63f8(%rip), %r14      # 0xb988
movq (%r14), %rdi
testl %esi, %esi
je 0x55f8
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x20d0
movq (%r14), %r14
movq (%rbx), %r15
xorl %eax, %eax
callq 0x33a8
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x25d0
testb $0x2, 0xa8(%rbx)
je 0x55ec
movq (%rbx), %rdi
leaq 0x63ea(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
leaq 0x63f0(%rip), %rax      # 0xb9d0
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3420
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a0e
jmp 0x5626
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
xorl %ebp, %ebp
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x21c0
movq %rbx, %rdi
movl %ebp, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x563a
// File: /workspace/github_c_makefile_star2_O3/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 0x633a(%rip), %r14      # 0xb988
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 0x2500
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2090
testl %ebp, %ebp
je 0x56c4
cmpl $0x0, 0xa4(%rbx)
je 0x56c4
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
movq 0x20(%rax), %rdx
leaq 0x5c95(%rip), %rax      # 0xb334
movl (%rax), %ecx
movl 0x30(%rbx), %r9d
leaq 0x5c84(%rip), %rax      # 0xb330
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_O3/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 0x5765
movq %rdi, %rbx
movq 0x645f(%rip), %rdi      # 0xbb40
cmpq %rbx, %rdi
je 0x5763
testq %rdi, %rdi
je 0x5710
xorl %esi, %esi
callq 0x5568
movq 0x6447(%rip), %rax      # 0xbb40
movq 0xf8(%rax), %rdi
cmpq 0xf8(%rbx), %rdi
je 0x5710
xorl %eax, %eax
callq 0x4ae5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5568
movq 0x6424(%rip), %rax      # 0xbb48
testq %rax, %rax
je 0x573d
cmpq %rbx, 0x20(%rax)
jne 0x5737
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rax), %rax
jmp 0x5724
movq 0x63fc(%rip), %rax      # 0xbb40
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x575c
cmpl $0x1, 0x98(%rax)
je 0x575c
movq 0x20(%rax), %rax
jmp 0x5744
movq %rbx, 0x63dd(%rip)      # 0xbb40
popq %rbx
retq
callq 0x28fc
jmp 0x5763
// File: /workspace/github_c_makefile_star2_O3/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 0x63c6(%rip), %rdi      # 0xbb40
testq %rdi, %rdi
je 0x57bc
xorl %esi, %esi
callq 0x5568
movq 0x63b3(%rip), %rax      # 0xbb40
movq %rax, %rdi
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x57ae
cmpl $0x1, 0x98(%rdi)
jne 0x5790
addq $0x78, %rsp
popq %rbx
popq %r14
jmp 0x56cd
movq 0xf8(%rax), %rdi
xorl %eax, %eax
callq 0x4ae5
movq $0x0, 0x6379(%rip) # 0xbb40
movq 0x6382(%rip), %rbx      # 0xbb50
testq %rbx, %rbx
jne 0x583a
leaq 0x8(%rsp), %rax
movl $0x1, 0x58(%rax)
leaq 0x61a2(%rip), %rbx      # 0xb988
movq (%rbx), %rdi
leaq 0x6230(%rip), %rcx      # 0xba20
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 0x2390
addq $0x30, %rsp
movq %rax, 0x6328(%rip)      # 0xbb50
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x24d0
movq 0x6316(%rip), %rbx      # 0xbb50
leaq 0x6147(%rip), %rax      # 0xb988
movq (%rax), %r14
xorl %eax, %eax
callq 0x33a8
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movq %rax, %rcx
callq 0x25d0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x62d8(%rip), %rcx      # 0xbb48
testq %rcx, %rcx
je 0x58b2
cmpq %rdx, %rcx
je 0x5891
movq %rcx, %rax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x58b2
cmpq %rdx, %rcx
jne 0x587a
addq $0x18, %rax
jmp 0x5898
leaq 0x62b0(%rip), %rax      # 0xbb48
movq 0x18(%rdx), %rcx
movq %rcx, (%rax)
movq 0x62a2(%rip), %rax      # 0xbb48
movq %rax, 0x18(%rdx)
movq %rdx, 0x6297(%rip)      # 0xbb48
retq
movq 0x573f(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x1e69(%rip), %rsi      # 0x772c
xorl %eax, %eax
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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 0x5932
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3381
testq %rax, %rax
jne 0x5934
movq 0x6258(%rip), %r15      # 0xbb48
testq %r15, %r15
je 0x590c
movq %r15, %rbx
cmpq %r14, (%rbx)
je 0x5934
cmpq %r14, 0x8(%rbx)
je 0x5934
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x58f8
testl %ebp, %ebp
je 0x5932
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x2250
movq %rax, %rbx
movq %r14, (%rax)
movq %r15, 0x18(%rax)
movq %rax, 0x6218(%rip)      # 0xbb48
jmp 0x5934
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x61f3(%rip), %rax      # 0xbb40
testq %rax, %rax
je 0x5970
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x5970
cmpq %rbx, %rcx
jne 0x5968
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0x5952
movq 0x61d1(%rip), %rax      # 0xbb48
cmpq %rbx, %rax
jne 0x5987
movq 0x18(%rbx), %rax
movq %rax, 0x61c1(%rip)      # 0xbb48
testq %rax, %rax
je 0x59aa
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x59aa
cmpq %rbx, %rcx
jne 0x59a2
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0x598c
cmpl $0x3, 0x98(%rbx)
jne 0x59bf
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x54dd
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
cmpq 0x8(%rax), %rsi
je 0x59df
leaq 0x5fb1(%rip), %rax      # 0xb988
movq (%rax), %rdi
callq 0x2270
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpq %rbx, 0x6154(%rip)      # 0xbb40
jne 0x5a30
movq 0x20(%rbx), %rdi
movq %rdi, 0x6147(%rip)      # 0xbb40
testq %rdi, %rdi
je 0x5a2b
movq 0xf8(%rbx), %rax
cmpq %rax, 0xf8(%rdi)
je 0x5a1f
movq %rax, %rdi
xorl %eax, %eax
callq 0x4ae5
movq 0x6121(%rip), %rdi      # 0xbb40
movl $0x1, %esi
callq 0x5568
jmp 0x5a30
callq 0x576c
cmpl $0x0, 0xe0(%rbx)
je 0x5a51
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5a62
callq 0x2170
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x5a73
callq 0x2170
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x5a84
callq 0x2170
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x5a95
callq 0x2170
movq %rbx, %rdi
popq %rbx
jmp 0x2080
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5adb
xorl %eax, %eax
callq 0x33a8
movq %rax, %r8
leaq 0x5ea6(%rip), %rax      # 0xb988
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_O3/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
cmpl $0x5, (%rdi)
jne 0x5b37
movq %rdi, %rbx
movl $0x1f00, %eax           # imm = 0x1F00
andl 0x50(%rdi), %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
je 0x5b73
leaq 0x40(%rsp), %rbx
leaq 0x5e45(%rip), %r15      # 0xb988
leaq 0x8(%rsp), %r14
movl $0x1f00, %ebp           # imm = 0x1F00
movq (%r15), %rdi
movl $0x200c, %esi           # imm = 0x200C
movq %r14, %rdx
callq 0x2600
cmpl $0x5, 0x8(%rsp)
jne 0x5b4d
movl 0x58(%rsp), %eax
andl %ebp, %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
jne 0x5b4d
jmp 0x5b77
addq $0x38, %rbx
leaq 0x5e0a(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x22f0
movl (%rbx), %eax
leaq 0x5e16(%rip), %rcx      # 0xb9a8
movl %eax, (%rcx)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33a8
leaq 0x5825(%rip), %r12      # 0xb988
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 0x61ad
leaq 0x15fe(%rip), %rdi      # 0x779a
xorl %r15d, %r15d
movl %eax, %esi
xorl %eax, %eax
callq 0x6d44
jmp 0x624b
xorl %r14d, %r14d
movq %rsp, %r15
movq (%r12), %rdi
movl $0xc, %esi
movq %r15, %rdx
callq 0x2600
movl (%rsp), %eax
cmpl $0x5, %eax
je 0x6211
cmpl $0x4, %eax
jne 0x61b3
cmpl $0x3, 0x54(%rsp)
jne 0x625e
movq 0x30(%rsp), %r14
testl %ebp, %ebp
jne 0x61b3
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
movq %rax, %r15
testq %rax, %rax
jne 0x6201
movq %rsp, %rdi
callq 0x5b13
testq %rbx, %rbx
je 0x624b
movl 0x50(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
jmp 0x624b
movq %rsp, %r12
movq %r12, %rdi
callq 0x5b13
xorl %r15d, %r15d
cmpl $0x3, 0x54(%r12)
jne 0x624b
cmpq %r14, 0x30(%rsp)
jne 0x624b
testq %rbx, %rbx
je 0x623c
movl 0x50(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x58ca
movq %rax, %r15
movq %r15, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
callq 0x5b13
xorl %r15d, %r15d
jmp 0x624b
// File: /workspace/github_c_makefile_star2_O3/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 0x50a2(%rip), %rax      # 0xb330
movl (%rax), %r10d
addl %r10d, %r10d
subl %r10d, %r9d
subl %r10d, %r8d
movq 0x40(%rdi), %r11
testb $0x40, %r11b
je 0x62c8
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 0x62e2
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_O3/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 0x33a8
leaq 0x5240(%rip), %r12      # 0xb988
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 0x678f
leaq 0x1023(%rip), %rdi      # 0x77a4
movl %eax, %esi
xorl %eax, %eax
callq 0x6d44
jmp 0x682c
movq (%r12), %rdi
leaq 0x8(%rsp), %r14
movl $0xc, %esi
movq %r14, %rdx
callq 0x2600
cmpl $0x3, 0x54(%r14)
jne 0x6822
movzwl 0x40(%rbx), %eax
testl $0x110, %eax            # imm = 0x110
je 0x67f1
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 0x25c0
leaq -0x5a8(%rip), %rdx      # 0x626b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6428
movl %eax, %ebp
jmp 0x682c
leaq 0x8(%rsp), %rdi
callq 0x5b13
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_O3/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 0x68a1
leaq 0x4acc(%rip), %rax      # 0xb330
movl (%rax), %eax
movl 0x28(%rbx), %r10d
movl 0x2c(%rbx), %r11d
subl %eax, %r10d
subl %eax, %r11d
leaq 0x510d(%rip), %rax      # 0xb988
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 0x6900
leaq 0x28(%rbx), %r8
leaq 0x2c(%rbx), %r9
leaq 0x50d8(%rip), %rax      # 0xb988
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 0x22d0
addq $0x20, %rsp
leaq 0x4a47(%rip), %rax      # 0xb330
movq 0x28(%rbx), %xmm0
movd (%rax), %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x28(%rbx)
movq 0x8(%r15), %r14
movq 0x60(%r15), %r15
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x33a8
leaq 0x5070(%rip), %rcx      # 0xb988
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 0x695b
leaq 0xe5a(%rip), %rdi       # 0x77aa
movl %eax, %esi
xorl %eax, %eax
callq 0x6d44
jmp 0x696e
leaq -0x65d(%rip), %rdx      # 0x6305
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6428
movl %eax, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq