LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5576
testq %rax, %rax
je 0x3e69
movq %rax, %rbx
cmpq $0x44, %r14
je 0x3d88
cmpq $0x27, %r14
je 0x3d6e
cmpq $0x25, %r14
jne 0x3d96
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x3d5e
callq 0x2170
cmpl $0x1, %ebp
jne 0x3dec
xorl %eax, %eax
jmp 0x3df9
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d7f
callq 0x2170
cmpl $0x1, %ebp
jne 0x3dd6
xorl %eax, %eax
jmp 0x3de3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4516
leaq 0x7c73(%rip), %rax      # 0xba10
cmpq (%rax), %r14
jne 0x3e1f
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x49e0
movl %eax, 0xa4(%rbx)
leaq 0x7d84(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
jne 0x3e69
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x52d4
movq (%rbx), %rdi
pushq $0x27
popq %rsi
xorl %eax, %eax
callq 0x4980
movq %rax, 0xc8(%rbx)
jmp 0x3e00
movq (%rbx), %rdi
pushq $0x25
popq %rsi
xorl %eax, %eax
callq 0x4980
movq %rax, 0xd0(%rbx)
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4878
movq 0xb0(%rbx), %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x51b2
leaq 0x7bb2(%rip), %rax      # 0xb9d8
cmpq (%rax), %r14
jne 0x3e4f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4749
leaq 0x7d04(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
jne 0x3e69
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x467f
leaq 0x7b6a(%rip), %rax      # 0xb9c0
cmpq (%rax), %r14
jne 0x3e69
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4a77
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x303c
testq %rax, %rax
je 0x3e94
cmpl $0x0, 0x40(%r14)
je 0x3ea1
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x30(%r14), %rdi
xorl %eax, %eax
callq 0x303c
movq 0x28(%r14), %rdi
testq %rax, %rax
je 0x3f1b
movq %rax, %rbx
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x3e94
movq %rax, %r14
cmpl $0x0, 0x30(%rax)
je 0x3ed7
cmpl $0x0, 0x34(%r14)
jne 0x3e94
leaq 0x7aaa(%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 0x3e94
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
jmp 0x3e94
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x3e94
movq 0x8(%rax), %rcx
movq 0xf8(%rax), %rdx
cmpq 0x8(%rdx), %rcx
je 0x3f4b
cmpl $0x0, 0x98(%rax)
jne 0x3e94
movq %rax, %rdi
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55e7
// File: /workspace/github_c_makefile_star2_O2/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 0x7a3c(%rip), %rcx      # 0xb9a8
movl %eax, (%rcx)
cmpl $0x1, 0x50(%rdi)
jne 0x3fc3
cmpl $0x4, 0x54(%rdi)
jne 0x3fc3
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x3fc3
movq %rax, %rbx
leaq 0x7baa(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
je 0x3fc3
leaq 0x79e6(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2350
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5526
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x5367
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x79d8(%rip), %rax      # 0xb9a8
andl $0x0, (%rax)
cmpl $0x4, 0x2c(%rdi)
jne 0x4034
movq %rdi, %r14
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x4034
movq %rax, %rbx
movq (%rax), %rax
cmpq 0x20(%r14), %rax
jne 0x4034
leaq 0x7b3f(%rip), %rax      # 0xbb40
cmpq (%rax), %rbx
je 0x4034
leaq 0x797b(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x2350
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5526
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5367
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/9wm[P]9wm/manage.c
// Function: scanwins
void
scanwins(ScreenInfo * s)
{
	unsigned int i, nwins;
	Client *c;
	Window dw1, dw2, *wins;
	XWindowAttributes attr;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x7548(%rip), %r15      # 0xb988
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
leaq 0xc(%rsp), %r9
callq 0x2130
leaq 0x20(%rsp), %r14
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movl 0xc(%rsp), %eax
cmpq %rax, %r12
jae 0x44fd
movq (%r15), %rdi
movq (%rsp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdx
callq 0x24a0
cmpl $0x0, 0x98(%rsp)
jne 0x44f5
movq (%rsp), %rax
movq (%rax,%r12,8), %rdi
cmpq 0x10(%rbx), %rdi
je 0x44f5
movl %ebp, %esi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x44f5
movq (%rax), %rcx
movq (%rsp), %rdx
cmpq (%rdx,%r12,8), %rcx
jne 0x44f5
cmpl $0x0, 0x9c(%rax)
jne 0x44f5
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 0x44f5
movq %rax, %rdi
movl %ebp, %esi
callq 0x403c
incq %r12
jmp 0x4469
movq (%rsp), %rdi
callq 0x2170
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x742a(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2430
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x45d3
movq (%r14), %rdi
movq (%rbx), %rsi
movq 0xf8(%rbx), %rax
movq 0x8(%rax), %rdx
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %r8d
callq 0x2050
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45d3
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x23e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x49e8
leaq 0x75c0(%rip), %rbx      # 0xbb78
movl $0x1, (%rbx)
movq (%r14), %rdi
xorl %esi, %esi
callq 0x23b0
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4701
movq %rax, %rbx
movl 0xe0(%rax), %r14d
testq %r14, %r14
jne 0x46bf
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x470c
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
testq %rax, %rax
je 0x470c
cmpl $0x0, 0xe0(%rax)
jne 0x4689
jmp 0x470c
xorl %ebp, %ebp
testl %r14d, %r14d
jle 0x46fd
leaq -0x1(%r14), %r15
movq 0xf0(%rbx), %rax
movq 0xf8(%rbx), %rdi
movq -0x8(%rax,%r14,8), %rsi
callq 0x4726
movq 0xe8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rax
xorl %ecx, %ecx
cmpq (%rbx), %rax
sete %cl
addl %ecx, %ebp
movq %r15, %r14
jmp 0x46c1
testl %ebp, %ebp
je 0x470c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8(%rbx), %rsi
movq 0xf8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4726
// File: /workspace/github_c_makefile_star2_O2/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 0x478b
leaq 0x721b(%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 0x7243(%rip), %rax      # 0xb9d8
movq (%rax), %rsi
pushq $0x21
popq %rdx
pushq $0x64
popq %rcx
leaq 0x8(%rsp), %r8
callq 0x4905
movl %eax, %ebp
cmpl $0x0, 0xe0(%rbx)
je 0x47cb
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
testl %ebp, %ebp
jle 0x485f
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 0x7182(%rip), %r13      # 0xb988
leaq 0x10(%rsp), %r14
cmpq %r12, %r15
je 0x4866
movq 0x8(%rsp), %rcx
movq (%rcx,%r12,8), %rsi
cmpq (%rbx), %rsi
jne 0x4827
movq 0xd8(%rbx), %rcx
jmp 0x4856
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
jmp 0x480b
andl $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_O2/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 0x48b9
movq 0xc8(%rbx), %rcx
testq %rcx, %rcx
jne 0x48b9
movq 0xb8(%rbx), %rcx
testq %rcx, %rcx
jne 0x48b9
movq 0xc0(%rbx), %rax
testq %rax, %rax
leaq 0x2d68(%rip), %rcx      # 0x761d
cmovneq %rax, %rcx
leaq 0x2d66(%rip), %r15      # 0x7626
movq %rcx, %r14
movq %rcx, %rdi
movq %r15, %rsi
callq 0x25f0
leaq 0x3(%rax), %rcx
testq %rax, %rax
jne 0x48c0
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x2160
testq %rax, %rax
je 0x48ea
movb $0x0, (%rax)
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x48ed
movq %r14, 0xb0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7064(%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
pushq $-0x1
popq %rax
testl %ecx, %ecx
je 0x4964
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x495a
movq (%rsp), %rax
testq %rax, %rax
jne 0x495a
callq 0x2170
movq (%rsp), %rax
jmp 0x495a
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x8(%r10)
movl %eax, 0x98(%rdi)
leaq 0x6f81(%rip), %rax      # 0xb988
movq (%rax), %rax
movq (%rdi), %rsi
leaq 0x6f9c(%rip), %rcx      # 0xb9b0
movq (%rcx), %rcx
pushq $0x20
popq %r8
movq %rax, %rdi
movq %rcx, %rdx
xorl %r9d, %r9d
pushq $0x2
pushq %r10
callq 0x2370
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %r8
andq $0x0, (%r8)
movq %rsi, %rbx
leaq 0x6f66(%rip), %rax      # 0xb9b0
movq (%rax), %rdx
pushq $0x2
popq %rcx
movq %rdx, %rsi
callq 0x4905
testl %eax, %eax
jle 0x4a6f
movq 0x8(%rsp), %rdi
movl (%rdi), %eax
movl %eax, (%rbx)
callq 0x2170
pushq $0x1
popq %rax
jmp 0x4a71
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0xa8(%rbx)
leaq 0x6f30(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
pushq $0x4
popq %rdx
pushq $0x14
popq %rcx
leaq 0x8(%rsp), %r8
callq 0x4905
testl %eax, %eax
jle 0x4af6
movq 0x8(%rsp), %rdi
leaq 0x6f15(%rip), %rcx      # 0xb9c8
movq (%rcx), %rcx
leaq 0x6f13(%rip), %rdx      # 0xb9d0
movq (%rdx), %rdx
movl %eax, %eax
xorl %esi, %esi
pushq $0x1
popq %r8
pushq $0x2
popq %r9
cmpq %rsi, %rax
je 0x4af1
movq (%rdi,%rsi,8), %r11
movl %r8d, %r10d
cmpq %rcx, %r11
je 0x4ae5
movl %r9d, %r10d
cmpq %rdx, %r11
jne 0x4aec
orl %r10d, 0xa8(%rbx)
incq %rsi
jmp 0x4acc
callq 0x2170
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d46
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6c3b(%rip), %rax      # 0xb988
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x2210
cmpb $0x0, 0x78(%r14)
je 0x4d6b
addq $0x78, %r14
movq %r14, %rdi
callq 0x2260
testq %rbx, %rbx
je 0x4db8
leaq 0x6c09(%rip), %r14      # 0xb980
movq (%r14), %rdi
leaq 0x28e7(%rip), %rdx      # 0x7668
movq %rdi, %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x25a0
movq 0x6260(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x28c6(%rip), %rsi      # 0x766b
xorl %eax, %eax
callq 0x22c0
leaq 0x27ae(%rip), %rdi      # 0x7561
callq 0x24b0
leaq 0x28b9(%rip), %rdi      # 0x7678
movq %rdi, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2580
leaq 0x28ac(%rip), %rdi      # 0x767e
callq 0x24b0
pushq $0x1
popq %rdi
callq 0x2530
// File: /workspace/github_c_makefile_star2_O2/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 0x4e84
movq %rdi, %rbx
movl 0x30(%rdi), %r14d
movl 0x34(%rdi), %ebp
xorl %eax, %eax
callq 0x6297
testl %eax, %eax
je 0x4e84
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5367
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5526
leaq 0x6b68(%rip), %r15      # 0xb988
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
callq 0x2590
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x64f3(%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 0x4e8d
cmpl %ebp, %r9d
jne 0x4e8d
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3189
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_O2/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 0x4f16
movq %rdi, %rbx
xorl %eax, %eax
callq 0x636b
testl %eax, %eax
je 0x4f16
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5367
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5526
leaq 0x6aae(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2590
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
leaq 0x6439(%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 0x3189
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4f52
testl %esi, %esi
jne 0x4f53
movl 0xa8(%rdi), %eax
andl $0x1, %eax
je 0x4f53
movq (%rdi), %rdi
leaq 0x6a84(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
leaq 0x6a82(%rip), %rax      # 0xb9c8
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x30e5
retq
leaq 0x6a2e(%rip), %rax      # 0xb988
movq (%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/9wm[P]9wm/menu.c
// Function: hide
void
hide(Client * c)
{
	int i;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5020
cmpl $0x20, 0x6ab4(%rip)     # 0xba30
je 0x5020
movq %rdi, %rbx
cmpl $0x3, 0x98(%rdi)
je 0x5028
leaq 0x69ef(%rip), %r14      # 0xb988
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2430
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2430
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x49e8
leaq 0x6b7c(%rip), %rax      # 0xbb40
cmpq %rbx, (%rax)
jne 0x4fd0
xorl %eax, %eax
callq 0x541d
movl 0x6a5a(%rip), %eax      # 0xba30
leaq 0x6a63(%rip), %rcx      # 0xba40
leaq 0x63ac(%rip), %rdx      # 0xb390
movq %rax, %rsi
testl %esi, %esi
jle 0x5003
movq -0x8(%rcx,%rsi,8), %rdi
movq %rdi, (%rcx,%rsi,8)
movq 0x20(%rdx,%rsi,8), %rdi
movq %rdi, 0x28(%rdx,%rsi,8)
decq %rsi
jmp 0x4fe7
movq %rbx, 0x6a36(%rip)      # 0xba40
movq 0xb0(%rbx), %rcx
movq %rcx, 0x63a0(%rip)      # 0xb3b8
incl %eax
movl %eax, 0x6a10(%rip)      # 0xba30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5fc9(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq 0xb0(%rbx), %rdx
leaq 0x2655(%rip), %rsi      # 0x7695
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movl %edi, %edx
movl 0x69d2(%rip), %ecx      # 0xba30
cmpl %edi, %ecx
jle 0x5111
movslq %edx, %r15
leaq 0x69d0(%rip), %r14      # 0xba40
movq (%r14,%r15,8), %rbx
cmpl $0x3, 0x98(%rbx)
jne 0x5134
testl %esi, %esi
je 0x50cc
leaq 0x68fc(%rip), %r12      # 0xb988
movq (%r12), %rdi
movq (%rbx), %rsi
callq 0x24d0
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x2350
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x49e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5367
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5526
movl 0x6964(%rip), %ecx      # 0xba30
leal -0x1(%rcx), %eax
movl %eax, 0x695b(%rip)      # 0xba30
movslq %eax, %rdx
leaq 0x62b1(%rip), %rax      # 0xb390
cmpq %rdx, %r15
jge 0x50fc
movq 0x8(%r14,%r15,8), %rsi
movq %rsi, (%r14,%r15,8)
movq 0x30(%rax,%r15,8), %rsi
movq %rsi, 0x28(%rax,%r15,8)
incq %r15
jmp 0x50df
movslq %ecx, %rcx
andq $0x0, 0x20(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5ee0(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x258c(%rip), %rsi      # 0x76ae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22c0
movq 0x5ebd(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq 0xb0(%rbx), %rdx
movl (%rbx), %ecx
leaq 0x2580(%rip), %rsi      # 0x76ce
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x68ca(%rip), %ecx      # 0xba30
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
leaq 0x68cc(%rip), %rdx      # 0xba40
cmpq %rax, %rcx
je 0x518e
cmpq %rdi, (%rdx)
je 0x5187
incq %rax
addq $0x8, %rdx
jmp 0x5174
movl %eax, %edi
jmp 0x504e
movq 0x5e63(%rip), %rax      # 0xaff8
movq (%rax), %rax
movq 0xb0(%rdi), %rdx
movl (%rdi), %ecx
leaq 0x2549(%rip), %rsi      # 0x76f1
movq %rax, %rdi
xorl %eax, %eax
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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 0x2559(%rip), %rax      # 0x7715
cmovneq %rsi, %rax
movq %rax, 0xb0(%rdi)
cmpl $0x3, 0x98(%rdi)
jne 0x5205
movl 0x685a(%rip), %edx      # 0xba30
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
shlq $0x3, %rdx
leaq 0x6858(%rip), %rsi      # 0xba40
cmpq %rcx, %rdx
je 0x5205
cmpq %rdi, (%rcx,%rsi)
je 0x51f9
addq $0x8, %rcx
jmp 0x51e8
leaq 0x6190(%rip), %rdx      # 0xb390
movq %rax, 0x28(%rcx,%rdx)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x521a
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6757(%rip), %r15      # 0xb988
movq (%r15), %rdi
testl %esi, %esi
je 0x5298
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x20d0
movq (%r15), %r15
movq (%r14), %r12
xorl %eax, %eax
callq 0x3073
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x25d0
testb $0x2, 0xa8(%r14)
je 0x528c
movq (%r14), %rdi
leaq 0x674a(%rip), %rax      # 0xb9c0
movq (%rax), %rsi
leaq 0x6750(%rip), %rax      # 0xb9d0
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x30e5
movq %r14, %rdi
xorl %eax, %eax
callq 0x467f
jmp 0x52bf
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
pushq $0xc
popq %r9
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
callq 0x21c0
movq %r14, %rdi
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52d4
// File: /workspace/github_c_makefile_star2_O2/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 0x66a0(%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 0x535e
cmpl $0x0, 0xa4(%rbx)
je 0x535e
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
movq 0x20(%rax), %rdx
leaq 0x5ffb(%rip), %rax      # 0xb334
movl (%rax), %ecx
movl 0x30(%rbx), %r9d
leaq 0x5fea(%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_O2/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:
testq %rdi, %rdi
je 0x5401
pushq %rbx
movq %rdi, %rbx
movq 0x67c5(%rip), %rdi      # 0xbb40
cmpq %rbx, %rdi
je 0x53ff
testq %rdi, %rdi
je 0x53aa
xorl %esi, %esi
callq 0x5208
movq 0x67ad(%rip), %rax      # 0xbb40
movq 0xf8(%rax), %rdi
cmpq 0xf8(%rbx), %rdi
je 0x53aa
xorl %eax, %eax
callq 0x4745
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5208
leaq 0x678c(%rip), %rax      # 0xbb48
movq (%rax), %rax
testq %rax, %rax
je 0x53d8
cmpq %rbx, 0x20(%rax)
jne 0x53d2
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x18, %rax
jmp 0x53bc
leaq 0x6761(%rip), %rax      # 0xbb40
movq (%rax), %rcx
movq %rcx, 0x20(%rbx)
testq %rcx, %rcx
je 0x53f8
leaq 0x20(%rcx), %rax
cmpl $0x1, 0x98(%rcx)
jne 0x53df
movq %rbx, 0x6741(%rip)      # 0xbb40
popq %rbx
retq
movq 0x5bf0(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x2307(%rip), %rdi      # 0x7719
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2540
// File: /workspace/github_c_makefile_star2_O2/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 $0xa8, %rsp
movq 0x6712(%rip), %rdi      # 0xbb40
testq %rdi, %rdi
je 0x5473
xorl %esi, %esi
callq 0x5208
movq 0x66ff(%rip), %rax      # 0xbb40
movq %rax, %rdi
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x5465
cmpl $0x1, 0x98(%rdi)
jne 0x5444
addq $0xa8, %rsp
popq %rbx
popq %r14
jmp 0x5367
movq 0xf8(%rax), %rdi
xorl %eax, %eax
callq 0x4745
andq $0x0, 0x66c5(%rip)      # 0xbb40
movq 0x66ce(%rip), %rbx      # 0xbb50
testq %rbx, %rbx
jne 0x54f9
leaq 0x38(%rsp), %rax
movl $0x1, 0x58(%rax)
leaq 0x64ee(%rip), %rbx      # 0xb988
movq (%rbx), %rdi
leaq 0x657c(%rip), %rcx      # 0xba20
movq (%rcx), %rcx
movq 0x8(%rcx), %rsi
andq $0x0, 0x18(%rsp)
movq %rax, 0x28(%rsp)
andl $0x0, 0x8(%rsp)
movq $0x200, 0x20(%rsp)      # imm = 0x200
andl $0x0, (%rsp)
movl $0x2, 0x10(%rsp)
pushq $0x1
popq %r8
xorl %edx, %edx
xorl %ecx, %ecx
movl %r8d, %r9d
callq 0x2390
movq %rax, 0x6669(%rip)      # 0xbb50
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x24d0
movq 0x6657(%rip), %rbx      # 0xbb50
leaq 0x6488(%rip), %rax      # 0xb988
movq (%rax), %r14
xorl %eax, %eax
callq 0x3073
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x25d0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x6618(%rip), %rcx      # 0xbb48
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x555e
movq %rcx, %rax
leaq 0x18(%rsi), %rcx
cmpq %rdx, %rsi
jne 0x5530
movq 0x18(%rdx), %rcx
movq %rcx, (%rax)
movq 0x65f6(%rip), %rax      # 0xbb48
movq %rax, 0x18(%rdx)
movq %rdx, 0x65eb(%rip)      # 0xbb48
retq
movq 0x5a93(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x21bd(%rip), %rsi      # 0x772c
xorl %eax, %eax
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x55dd
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x303c
testq %rax, %rax
jne 0x55df
leaq 0x65af(%rip), %rbx      # 0xbb48
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x55b2
cmpq %r14, (%rbx)
je 0x55df
cmpq %r14, 0x8(%rbx)
je 0x55df
addq $0x18, %rbx
jmp 0x5599
testl %ebp, %ebp
je 0x55dd
pushq $0x1
popq %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2250
movq %rax, %rbx
movq %r14, (%rax)
movq 0x6578(%rip), %rax      # 0xbb48
movq %rax, 0x18(%rbx)
movq %rbx, 0x656d(%rip)      # 0xbb48
jmp 0x55df
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x654e(%rip), %rax      # 0xbb40
testq %rax, %rax
je 0x5612
movq %rax, %rcx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x5612
cmpq %rbx, %rax
jne 0x55f2
movq 0x20(%rax), %rax
movq %rax, 0x20(%rcx)
jmp 0x55f2
movq 0x652f(%rip), %rax      # 0xbb48
cmpq %rbx, %rax
jne 0x562f
leaq 0x6523(%rip), %rcx      # 0xbb48
movq %rbx, %rax
movq 0x18(%rax), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x564b
movq %rax, %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x564b
cmpq %rbx, %rax
jne 0x562f
addq $0x18, %rcx
jmp 0x5628
cmpl $0x3, 0x98(%rbx)
jne 0x5660
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x5160
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rax
cmpq 0x8(%rax), %rsi
je 0x5680
leaq 0x6310(%rip), %rax      # 0xb988
movq (%rax), %rdi
callq 0x2270
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpq %rbx, 0x64b3(%rip)      # 0xbb40
jne 0x56cf
movq 0x20(%rbx), %rdi
movq %rdi, 0x64a6(%rip)      # 0xbb40
testq %rdi, %rdi
je 0x56ca
movq 0xf8(%rbx), %rax
cmpq %rax, 0xf8(%rdi)
je 0x56c0
movq %rax, %rdi
xorl %eax, %eax
callq 0x4745
movq 0x6480(%rip), %rdi      # 0xbb40
pushq $0x1
popq %rsi
callq 0x5208
jmp 0x56cf
callq 0x541d
cmpl $0x0, 0xe0(%rbx)
je 0x56f0
movq 0xe8(%rbx), %rdi
callq 0x2170
movq 0xf0(%rbx), %rdi
callq 0x2080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5701
callq 0x2170
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x5712
callq 0x2170
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x5723
callq 0x2170
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x5734
callq 0x2170
movq %rbx, %rdi
popq %rbx
jmp 0x2080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x577b
xorl %eax, %eax
callq 0x3073
movq %rax, %r8
leaq 0x6206(%rip), %rax      # 0xb988
movq (%rax), %rdi
movslq %r8d, %rax
subq $0x8, %rsp
pushq $0x1
popq %r8
movq %r15, %rsi
xorl %edx, %edx
movl %ebp, %ecx
movl %r8d, %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_O2/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
callq 0x5740
testl %eax, %eax
je 0x57cd
addq $0x38, %rbx
jmp 0x5807
leaq 0x40(%rsp), %rbx
leaq 0x61af(%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 0x57e3
movl 0x58(%rsp), %eax
andl %ebp, %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
jne 0x57e3
leaq 0x617a(%rip), %rax      # 0xb988
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x22f0
movl (%rbx), %eax
leaq 0x6186(%rip), %rcx      # 0xb9a8
movl %eax, (%rcx)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rdx), %rdi
movq 0x50(%rdx), %rcx
pushq $0xc
popq %rdx
movq %rdi, %rsi
xorl %r8d, %r8d
callq 0x575a
testl %eax, %eax
je 0x5dce
leaq 0x19dd(%rip), %rdi      # 0x779a
xorl %r15d, %r15d
movl %eax, %esi
xorl %eax, %eax
callq 0x67ef
jmp 0x5e7c
xorl %r14d, %r14d
leaq 0x5bb0(%rip), %r13      # 0xb988
pushq $0xc
popq %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2600
movl 0x8(%rsp), %eax
cmpl $0x5, %eax
je 0x5e40
cmpl $0x4, %eax
jne 0x5de1
cmpl $0x3, 0x5c(%rsp)
jne 0x5e91
movq 0x38(%rsp), %r14
testl %ebp, %ebp
jne 0x5de1
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
movq %rax, %r15
testq %rax, %rax
jne 0x5e30
leaq 0x8(%rsp), %rdi
callq 0x57ae
testq %rbx, %rbx
je 0x5e7c
movl 0x58(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
jmp 0x5e7c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x57ae
xorl %r15d, %r15d
cmpl $0x3, 0x54(%r12)
jne 0x5e7c
cmpq %r14, 0x38(%rsp)
jne 0x5e7c
testq %rbx, %rbx
je 0x5e6d
movl 0x58(%rsp), %eax
andl $0x1, %eax
movl %eax, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x5576
movq %rax, %r15
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x57ae
xorl %r15d, %r15d
jmp 0x5e7c
// File: /workspace/github_c_makefile_star2_O2/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 0x546d(%rip), %rax      # 0xb330
movl (%rax), %r10d
addl %r10d, %r10d
subl %r10d, %r9d
subl %r10d, %r8d
movq 0x40(%rdi), %r11
testb $0x40, %r11b
je 0x5efd
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 0x5f17
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_O2/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 0x6002
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 0x59d7(%rip), %rax      # 0xb988
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 0x59b5(%rip), %rax      # 0xb988
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_O2/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
movl %edi, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
imull $0x3e8, %edx, %eax      # imm = 0x3E8
cltq
movq %rax, 0x8(%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2300
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq 0xf8(%rdi), %r14
movq 0x8(%r14), %rdi
movq 0x58(%r14), %rcx
pushq $0xc
popq %rdx
xorl %ebp, %ebp
movq %rdi, %rsi
xorl %r8d, %r8d
callq 0x575a
testl %eax, %eax
je 0x62de
leaq 0x14d1(%rip), %rdi      # 0x77a4
movl %eax, %esi
xorl %eax, %eax
callq 0x67ef
jmp 0x6359
leaq 0x56a3(%rip), %r12      # 0xb988
movq (%r12), %rdi
pushq $0xc
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x2600
cmpl $0x3, 0x54(%r15)
jne 0x6351
movzwl 0x40(%rbx), %eax
testw $0x110, %ax             # imm = 0x110
je 0x6324
movl 0x90(%rbx), %edi
movl 0x94(%rbx), %esi
addl 0x40(%rsp), %edi
addl 0x44(%rsp), %esi
movq %r14, %rdx
callq 0x645d
movq (%r12), %rdi
movq 0x60(%r14), %rdx
movq %rsp, %r14
movq 0x38(%r14), %rcx
pushq $0xc
popq %rsi
callq 0x25c0
leaq -0x4a2(%rip), %rdx      # 0x5ea0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6047
movl %eax, %ebp
jmp 0x6359
movq %rsp, %rdi
callq 0x57ae
movl %ebp, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq