LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: client_lower
void client_lower(struct client *c) {
	LOG_XDEBUG("XLowerWindow(window=%lx,parent=%lx)\n", (unsigned long)c->window, (unsigned long)c->parent);
	XLowerWindow(display.dpy, c->parent);
	clients_stacking_order = list_to_head(clients_stacking_order, c);
	ewmh_set_net_client_list_stacking(c->screen);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xb00f(%rip), %rax      # 0x10738
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x43f0
movq 0xafec(%rip), %rdi      # 0x10728
movq %rbx, %rsi
callq 0x8807
movq %rax, 0xafdd(%rip)      # 0x10728
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x7f36
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: send_config
void send_config(struct client *c) {
	XEvent ev = {
		.xconfigure = {
			.type = ConfigureNotify,
			.event = c->window,
			.window = c->window,
			.x = c->x,
			.y = c->y,
			.width = c->width,
			.height = c->height,
			.border_width = 0,
			.above = None,
			.override_redirect = False
		}
	};
	XSendEvent(display.dpy, c->window, False, StructureNotifyMask, &ev);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4080
movl $0x16, (%rbx)
movq (%r14), %rsi
movq %rsi, 0x20(%rbx)
movq %rsi, 0x28(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x30(%rbx)
movl 0x2c(%r14), %eax
movl %eax, 0x34(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x34(%r14), %eax
movl %eax, 0x3c(%rbx)
leaq 0xaf8e(%rip), %rax      # 0x10738
movq (%rax), %rdi
movl $0x20000, %ecx          # imm = 0x20000
xorl %edx, %edx
movq %rbx, %r8
callq 0x4520
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: client_gravitate
void client_gravitate(struct client *c, int bw) {
	int dx = 0, dy = 0;
	switch (c->win_gravity) {
	default:
	case NorthWestGravity:
		dx = bw;
		dy = bw;
		break;
	case NorthGravity:
		dy = bw;
		break;
	case NorthEastGravity:
		dx = -bw;
		dy = bw;
		break;
	case EastGravity:
		dx = -bw;
		break;
	case CenterGravity:
		break;
	case WestGravity:
		dx = bw;
		break;
	case SouthWestGravity:
		dx = bw;
		dy = -bw;
		break;
	case SouthGravity:
		dy = -bw;
		break;
	case SouthEastGravity:
		dx = -bw;
		dy = -bw;
		break;
	}
	// Don't gravitate if client would be maximised along either axis
	// (unless it's offset already).
	if (c->x != 0 || c->width != DisplayWidth(display.dpy, c->screen->screen)) {
		c->x += dx;
	}
	if (c->y != 0 || c->height != DisplayHeight(display.dpy, c->screen->screen)) {
		c->y += dy;
	}
}

// Assembly:
movl 0x90(%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x57f5
xorl %eax, %eax
leaq 0x5c32(%rip), %rdx      # 0xb410
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
jmp 0x5803
negl %esi
movl %esi, %eax
xorl %esi, %esi
jmp 0x5803
negl %esi
movl %esi, %eax
jmp 0x5803
movl %esi, %eax
negl %eax
jmp 0x5803
movl %esi, %eax
negl %esi
movl 0x28(%rdi), %ecx
testl %ecx, %ecx
jne 0x5830
movl 0x30(%rdi), %edx
leaq 0xaf24(%rip), %r8       # 0x10738
movq (%r8), %r8
movq 0xe8(%r8), %r8
movq 0x10(%rdi), %r9
movslq (%r9), %r9
shlq $0x7, %r9
cmpl 0x18(%r8,%r9), %edx
je 0x5835
addl %eax, %ecx
movl %ecx, 0x28(%rdi)
movl 0x2c(%rdi), %eax
testl %eax, %eax
jne 0x5862
movl 0x34(%rdi), %ecx
leaq 0xaef2(%rip), %rdx      # 0x10738
movq (%rdx), %rdx
movq 0xe8(%rdx), %rdx
movq 0x10(%rdi), %r8
movslq (%r8), %r8
shlq $0x7, %r8
cmpl 0x1c(%rdx,%r8), %ecx
je 0x5867
addl %esi, %eax
movl %eax, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: select_client
void select_client(struct client *c) {
	struct client *old_current = current;
	if (current)
		XSetWindowBorder(display.dpy, current->parent, current->screen->bg.pixel);
	if (c) {
		unsigned long bpixel;
		if (is_fixed(c))
			bpixel = c->screen->fc.pixel;
		else
			bpixel = c->screen->fg.pixel;
		XSetWindowBorder(display.dpy, c->parent, bpixel);
		XInstallColormap(display.dpy, c->cmap);
		XSetInputFocus(display.dpy, c->window, RevertToPointerRoot, CurrentTime);
	}
	current = c;
	// Update _NET_WM_STATE_FOCUSED for old current and _NET_ACTIVE_WINDOW
	// on its screen root.
	if (old_current)
		ewmh_set_net_wm_state(old_current);
	// Now do same for new current.
	if (c)
		ewmh_set_net_wm_state(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xaeb9(%rip), %r14      # 0x10730
testq %r14, %r14
je 0x5897
leaq 0xaeb5(%rip), %rax      # 0x10738
movq (%rax), %rdi
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
movq 0x40(%rax), %rdx
callq 0x4310
testq %rbx, %rbx
je 0x58e2
xorl %eax, %eax
cmpl $-0x1, 0x20(%rbx)
sete %al
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rcx
shll $0x5, %eax
movq 0x30(%rax,%rcx), %rdx
leaq 0xae7c(%rip), %r15      # 0x10738
movq (%r15), %rdi
callq 0x4310
movq (%r15), %rdi
movq 0x18(%rbx), %rsi
callq 0x4590
movq (%r15), %rdi
movq (%rbx), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x44c0
movq %rbx, 0xae47(%rip)      # 0x10730
testq %r14, %r14
je 0x58f6
movq %r14, %rdi
callq 0x8090
testq %rbx, %rbx
je 0x5908
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8090
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: client_to_vdesk
void client_to_vdesk(struct client *c, unsigned vdesk) {
	if (valid_vdesk(vdesk)) {
		c->vdesk = vdesk;
		if (c->vdesk == c->screen->vdesk || c->vdesk == VDESK_FIXED) {
			client_show(c);
		} else {
			client_hide(c);
		}
		ewmh_set_net_wm_desktop(c);
		select_client(current);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x5925
leaq 0xafe2(%rip), %rax      # 0x10900
cmpl %esi, 0x2c(%rax)
ja 0x5925
popq %rbx
retq
movl %esi, 0x20(%rbx)
cmpl $-0x1, %esi
je 0x5940
movq 0x10(%rbx), %rax
cmpl %esi, 0x60(%rax)
je 0x5940
movq %rbx, %rdi
callq 0x55fa
jmp 0x5948
movq %rbx, %rdi
callq 0x5692
movq %rbx, %rdi
callq 0x8250
movq 0xadd9(%rip), %rdi      # 0x10730
popq %rbx
jmp 0x5868
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: send_wm_delete
void send_wm_delete(struct client *c, int kill_client) {
	_Bool delete_supported = 0;
	int n;
	Atom *protocols;

	if (!kill_client && XGetWMProtocols(display.dpy, c->window, &protocols, &n)) {
		for (int i = 0; i < n; i++)
			if (protocols[i] == X_ATOM(WM_DELETE_WINDOW))
				delete_supported = 1;
		XFree(protocols);
	}
	if (delete_supported) {
		XEvent ev = {
			.xclient = {
				.type = ClientMessage,
				.window = c->window,
				.message_type = X_ATOM(WM_PROTOCOLS),
				.format = 32,
				.data.l = { X_ATOM(WM_DELETE_WINDOW), CurrentTime }
			}
		};
		XSendEvent(display.dpy, c->window, False, NoEventMask, &ev);
	} else {
		XKillClient(display.dpy, c->window);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x5b26
leaq 0xac2b(%rip), %rax      # 0x10738
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x4780
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac0b(%rip), %r15      # 0x10738
movq (%r15), %rdi
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x46a0
testl %eax, %eax
je 0x5b06
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rdi
testq %rax, %rax
jle 0x5bd3
movq 0x18(%r15), %rcx
xorl %edx, %edx
movl $0x1, %esi
xorl %ebp, %ebp
cmpq %rcx, (%rdi,%rdx,8)
movzbl %bpl, %ebp
cmovel %esi, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x5b62
movq 0x10(%rsp), %rdi
callq 0x4050
testb $0x1, %bpl
je 0x5b06
leaq 0x18(%rsp), %r14
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4080
movl $0x21, (%r14)
movq (%rbx), %rsi
movq %rsi, 0x20(%r14)
movq (%r15), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x28(%r14)
movl $0x20, 0x30(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x4520
jmp 0x5b18
callq 0x4050
jmp 0x5b06
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: set_shape
void set_shape(struct client *c) {
	Bool bounding_shaped;
	Bool b;  // dummy
	int i;  // dummy
	unsigned u;  // dummy

	if (!display.have_shape) return;

	// Logic to decide if we have a shaped window cribbed from fvwm-2.5.10.
	// Previous method (more than one rectangle returned from
	// XShapeGetRectangles) worked _most_ of the time.

	if (XShapeQueryExtents(display.dpy, c->window, &bounding_shaped, &i, &i,
				&u, &u, &b, &i, &i, &u, &u) && bounding_shaped) {
		LOG_DEBUG("%d shape extents\n", bounding_shaped);
		XShapeCombineShape(display.dpy, c->parent, ShapeBounding, 0, 0,
				c->window, ShapeBounding, ShapeSet);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0xab4d(%rip), %r14      # 0x10738
cmpl $0x0, 0x178(%r14)
je 0x5c50
movq %rdi, %rbx
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0xc(%rsp), %r9
leaq 0x10(%rsp), %rcx
leaq 0x14(%rsp), %rax
leaq 0x8(%rsp), %rdx
movq %rcx, %r8
pushq %r9
pushq %r9
pushq %rcx
pushq %rcx
pushq %rax
pushq %r9
callq 0x43e0
addq $0x30, %rsp
testl %eax, %eax
je 0x5c50
cmpl $0x0, 0x8(%rsp)
je 0x5c50
movq (%r14), %rdi
movq (%rbx), %r9
movq 0x8(%rbx), %rsi
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %rax
callq 0x4710
addq $0x10, %rsp
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client.c
// Function: create_info_window
void create_info_window(struct client *c) {
        display.info_window = XCreateSimpleWindow(display.dpy, c->screen->root, -4, -4, 2, 2,
                        0, c->screen->fg.pixel, c->screen->fg.pixel);
        XMapRaised(display.dpy, display.info_window);
        update_info_window(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaad2(%rip), %r14      # 0x10738
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rax), %rax
subq $0x8, %rsp
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
movl $0x2, %r8d
movl $0x2, %r9d
pushq %rax
pushq %rax
pushq $0x0
callq 0x4270
addq $0x20, %rsp
movq %rax, 0x198(%r14)
movq (%r14), %rdi
movq %rax, %rsi
callq 0x46f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5cbd
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client_move.c
// Function: draw_outline
static void draw_outline(struct client *c) {
#ifndef INFOBANNER_MOVERESIZE
	char buf[27];
	int width_inc = c->width_inc, height_inc = c->height_inc;
#endif

	XDrawRectangle(display.dpy, c->screen->root, c->screen->invert_gc,
		c->x - c->border, c->y - c->border,
		c->width + 2*c->border-1, c->height + 2*c->border-1);

#ifndef INFOBANNER_MOVERESIZE
	snprintf(buf, sizeof(buf), "%dx%d+%d+%d", (c->width-c->base_width)/width_inc,
			(c->height-c->base_height)/height_inc, c->x, c->y);
	XDrawString(display.dpy, c->screen->root, c->screen->invert_gc,
		c->x + c->width - XTextWidth(display.font, buf, strlen(buf)) - SPACE,
		c->y + c->height - SPACE,
		buf, strlen(buf));
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x7c(%rdi), %r14d
movl 0x80(%rdi), %ebp
leaq 0xa59e(%rip), %r15      # 0x10738
movq (%r15), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rax), %rdx
movl 0x28(%rbx), %ecx
movl 0x3c(%rbx), %eax
subl %eax, %ecx
movl 0x2c(%rbx), %r8d
subl %eax, %r8d
leal -0x1(,%rax,2), %eax
movl 0x30(%rbx), %r9d
addl %eax, %r9d
addl 0x34(%rbx), %eax
movl %eax, (%rsp)
callq 0x43c0
movl 0x30(%rbx), %eax
subl 0x84(%rbx), %eax
cltd
idivl %r14d
movl %eax, %ecx
movl 0x34(%rbx), %eax
subl 0x88(%rbx), %eax
cltd
idivl %ebp
movl 0x28(%rbx), %r9d
movl 0x2c(%rbx), %edx
movl %edx, (%rsp)
leaq 0x5233(%rip), %rdx      # 0xb430
leaq 0x10(%rsp), %r14
movl $0x1b, %esi
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
callq 0x40a0
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %r12
movl 0x28(%rbx), %ebp
movq (%r15), %r13
movq 0x160(%r15), %r15
addl 0x30(%rbx), %ebp
movq %r14, %rdi
callq 0x42f0
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x44e0
subl %eax, %ebp
addl $-0x3, %ebp
movl 0x2c(%rbx), %eax
movl 0x34(%rbx), %ecx
leal (%rax,%rcx), %ebx
addl $-0x3, %ebx
movq %r14, %rdi
callq 0x42f0
movl %eax, (%rsp)
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq %r14, %r9
callq 0x4030
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client_move.c
// Function: client_show_info
void client_show_info(struct client *c, XEvent *e) {
	unsigned input;

	if (e->type == KeyPress) {
		input = e->xkey.keycode;
		if (XGrabKeyboard(display.dpy, c->screen->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess)
			return;
	} else {
		input = e->xbutton.button;
		if (!grab_pointer(c->screen->root, None))
			return;
	}

#ifdef INFOBANNER
	create_info_window(c);
#else
	XGrabServer(display.dpy);
	draw_outline(c);
#endif

	for (;;) {
		XEvent ev;
		if (e->type == KeyPress) {
			XMaskEvent(display.dpy, KeyReleaseMask, &ev);
			if (ev.xkey.keycode != input)
				continue;
			if (XCheckIfEvent(display.dpy, &ev, predicate_keyrepeatpress, (XPointer)&ev)) {
				// Autorepeat keypress detected - ignore!
				continue;
			}
		} else {
			XMaskEvent(display.dpy, ButtonReleaseMask, &ev);
			if (ev.xbutton.button != input)
				continue;
		}
		break;
	}

#ifdef INFOBANNER
	remove_info_window();
#else
	draw_outline(c);
	XUngrabServer(display.dpy);
#endif

	if (e->type == KeyPress) {
		XUngrabKeyboard(display.dpy, CurrentTime);
	} else {
		XUngrabPointer(display.dpy, CurrentTime);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rsi), %ebp
cmpl $0x2, (%rsi)
leaq 0x9f2d(%rip), %r12      # 0x10738
movq (%r12), %rdi
movq 0x10(%r14), %rax
movq 0x10(%rax), %rsi
jne 0x6830
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x45e0
jmp 0x6858
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x4220
testl %eax, %eax
jne 0x68d5
movq %r14, %rdi
callq 0x5c58
leaq 0x20(%rsp), %r14
leaq 0x75(%rip), %r15        # 0x68e5
cmpl $0x2, (%rbx)
movq (%r12), %rdi
jne 0x68a4
movl $0x2, %esi
movq %r14, %rdx
callq 0x4510
cmpl %ebp, 0x74(%rsp)
jne 0x6870
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4550
testl %eax, %eax
jne 0x6870
jmp 0x68b7
movl $0x8, %esi
movq %r14, %rdx
callq 0x4510
cmpl %ebp, 0x74(%rsp)
jne 0x6870
callq 0x5ed3
cmpl $0x2, (%rbx)
movq (%r12), %rdi
jne 0x68ce
xorl %esi, %esi
callq 0x4450
jmp 0x68d5
xorl %esi, %esi
callq 0x41b0
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client_move.c
// Function: predicate_keyrepeatpress
static Bool predicate_keyrepeatpress(Display *dummy, XEvent *ev, XPointer arg) {
	(void)dummy;
	XEvent *release_event = (XEvent *)arg;
	if (ev->type != KeyPress)
		return False;
	if (release_event->xkey.keycode != ev->xkey.keycode)
		return False;
	return release_event->xkey.time == ev->xkey.time;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, (%rsi)
jne 0x6901
movl 0x54(%rdx), %ecx
cmpl 0x54(%rsi), %ecx
jne 0x6901
movq 0x38(%rdx), %rcx
xorl %eax, %eax
cmpq 0x38(%rsi), %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client_move.c
// Function: client_moveresize
void client_moveresize(struct client *c) {
	XMoveResizeWindow(display.dpy, c->parent, c->x - c->border, c->y - c->border,
			c->width, c->height);
	XMoveResizeWindow(display.dpy, c->window, 0, 0, c->width, c->height);
	send_config(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9e28(%rip), %r14      # 0x10738
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movl 0x3c(%rbx), %eax
subl %eax, %edx
movl 0x2c(%rbx), %ecx
subl %eax, %ecx
movl 0x30(%rbx), %r8d
movl 0x34(%rbx), %r9d
callq 0x43b0
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x30(%rbx), %r8d
movl 0x34(%rbx), %r9d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5755
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/client_move.c
// Function: client_select_next
void client_select_next(void) {
	struct list *newl = list_find(clients_tab_order, current);
	struct client *newc;

	do {
		if (newl) {
			newl = newl->next;
			if (!newl && !current)
				return;
		}
		if (!newl)
			newl = clients_tab_order;
		if (!newl)
			return;
		newc = newl->data;
		if (newc == current)
			return;
	} while ((!is_fixed(newc) && (newc->vdesk != newc->screen->vdesk))
		 || (newc->is_dock && !newc->screen->docks_visible));

	if (!newc)
		return;

	client_show(newc);  // XXX why would it be hidden?
	client_raise(newc);
	select_client(newc);

	// Optionally force the pointer to jump to the newly-selected window.
	// I think this was the default behaviour in much earlier versions of
	// evilwm (possibly to generate the enter event and handle selecting
	// the client as a result of that), but I don't like it now.

#ifdef WARP_POINTER
	setmouse(newc->window, newc->width + newc->border - 1,
			newc->height + newc->border - 1);
#endif

	discard_enter_events(newc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x9ba8(%rip), %rbx      # 0x10718
movq (%rbx), %rdi
leaq 0x9bb6(%rip), %r14      # 0x10730
movq (%r14), %rsi
callq 0x8879
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
je 0x6b9a
movq (%rax), %rax
movq %rax, %rsi
orq %rcx, %rsi
jne 0x6b9c
jmp 0x6c01
xorl %eax, %eax
testq %rax, %rax
cmoveq %rdx, %rax
testq %rax, %rax
je 0x6c01
movq 0x8(%rax), %rbx
cmpq %rcx, %rbx
je 0x6c01
movl 0x20(%rbx), %esi
cmpl $-0x1, %esi
je 0x6bc2
movq 0x10(%rbx), %rdi
cmpl 0x60(%rdi), %esi
jne 0x6b88
cmpl $0x0, 0x94(%rbx)
je 0x6bd5
movq 0x10(%rbx), %rsi
cmpl $0x0, 0x68(%rsi)
je 0x6b88
testq %rbx, %rbx
je 0x6c01
movq %rbx, %rdi
callq 0x5692
movq %rbx, %rdi
callq 0x56e7
movq %rbx, %rdi
callq 0x5868
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9ac4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/display.c
// Function: display_close
void display_close(void) {
	XSetInputFocus(display.dpy, PointerRoot, RevertToPointerRoot, CurrentTime);

	if (display.font)
		XFreeFont(display.dpy, display.font);

	for (int i = 0; i < display.nscreens; i++) {
		screen_deinit(&display.screens[i]);
		XFreeGC(display.dpy, display.screens[i].invert_gc);
		XInstallColormap(display.dpy, DefaultColormap(display.dpy, i));
		free(display.screens[i].display);
	}

	free(display.screens);

	XCloseDisplay(display.dpy);
	display.dpy = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x92eb(%rip), %rdi      # 0x10738
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x44c0
movq 0x9433(%rip), %rsi      # 0x10898
testq %rsi, %rsi
je 0x7476
movq 0x92c7(%rip), %rdi      # 0x10738
callq 0x4170
cmpl $0x0, 0x9443(%rip)      # 0x108c0
jle 0x74f0
movl $0x50, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x9437(%rip), %rdi      # 0x108c8
addq %r14, %rdi
callq 0x939e
movq 0x9298(%rip), %rdi      # 0x10738
movq 0x9421(%rip), %rax      # 0x108c8
movq 0x28(%rax,%r14), %rsi
callq 0x4390
movq 0x9280(%rip), %rdi      # 0x10738
movq 0xe8(%rdi), %rax
movq (%rax,%rbx), %rsi
callq 0x4590
movq 0x93f9(%rip), %rax      # 0x108c8
movq 0x8(%rax,%r14), %rdi
callq 0x42d0
incq %r15
movslq 0x93dd(%rip), %rax      # 0x108c0
addq $0x78, %r14
subq $-0x80, %rbx
cmpq %rax, %r15
jl 0x748a
movq 0x93d1(%rip), %rdi      # 0x108c8
callq 0x42d0
movq 0x9235(%rip), %rdi      # 0x10738
callq 0x4330
movq $0x0, 0x9225(%rip) # 0x10738
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/display.c
// Function: display_manage_clients
void display_manage_clients(void) {
	for (int i = 0; i < display.nscreens; i++) {
		struct screen *s = &display.screens[i];

		LOG_XENTER("XQueryTree(screen=%d)", i);
		unsigned nwins;
		Window dw1, dw2, *wins;
		XQueryTree(display.dpy, s->root, &dw1, &dw2, &wins, &nwins);
		LOG_XDEBUG("%u windows\n", nwins);
		LOG_XLEAVE();

		// Manage all relevant windows
		for (unsigned j = 0; j < nwins; j++) {
			XWindowAttributes winattr;
			XGetWindowAttributes(display.dpy, wins[j], &winattr);
			// Override redirect implies a pop-up that we should ignore.
			// If map_state is not IsViewable, it shouldn't be shown right
			// now, so don't try to manage it.
			if (!winattr.override_redirect && winattr.map_state == IsViewable)
				client_manage_new(wins[j], s);
		}
		XFree(wins);
	}
}

// Assembly:
cmpl $0x0, 0x93a0(%rip)      # 0x108c0
jle 0x75f5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
leaq 0x20(%rsp), %r13
movq 0x9379(%rip), %rbp      # 0x108c8
imulq $0x78, %rbx, %r14
movq 0x91de(%rip), %rdi      # 0x10738
movq 0x10(%rbp,%r14), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x4740
cmpl $0x0, 0x4(%rsp)
je 0x75c7
addq %r14, %rbp
xorl %r14d, %r14d
movq 0x91b0(%rip), %rdi      # 0x10738
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdx
callq 0x4630
cmpl $0x0, 0x98(%rsp)
jne 0x75bb
cmpl $0x2, 0x7c(%rsp)
jne 0x75bb
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rdi
movq %rbp, %rsi
callq 0x6c0c
incq %r14
movl 0x4(%rsp), %eax
cmpq %rax, %r14
jb 0x7581
movq 0x8(%rsp), %rdi
callq 0x4050
incq %rbx
movslq 0x92e5(%rip), %rax      # 0x108c0
cmpq %rax, %rbx
jl 0x7548
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_screen_workarea
void ewmh_set_screen_workarea(struct screen *s) {
	unsigned long workarea[4] = {
		0, 0,
		DisplayWidth(display.dpy, s->screen), DisplayHeight(display.dpy, s->screen)
	};
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_GEOMETRY),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea[2], 2);
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_VIEWPORT),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea[0], 2);
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_WORKAREA),
			XA_CARDINAL, 32, PropModeReplace,
			(unsigned char *)&workarea, 4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rax)
leaq 0x8957(%rip), %r14      # 0x10738
movq (%r14), %rdi
movq 0x60(%r14), %rdx
movq 0xe8(%rdi), %rcx
movslq (%rbx), %rsi
shlq $0x7, %rsi
movslq 0x18(%rcx,%rsi), %r8
movq %r8, (%rax)
movslq 0x1c(%rcx,%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rsi
movl $0x2, %r15d
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %rax
callq 0x4640
addq $0x10, %rsp
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x68(%r14), %rdx
movq %rsp, %r12
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %r12
callq 0x4640
addq $0x10, %rsp
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x80(%r14), %rdx
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x4
pushq %r12
callq 0x4640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list
void ewmh_set_net_client_list(struct screen *s) {
	Window *windows = alloc_window_array();
	int i = 0;
	if (windows) {
		for (struct list *iter = clients_mapping_order; iter; iter = iter->next) {
			struct client *c = iter->data;
			if (c->screen == s) {
				windows[i++] = c->window;
			}
		}
	}
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST),
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7efd
testq %rax, %rax
sete %dl
leaq 0x8885(%rip), %rcx      # 0x10720
movq (%rcx), %rcx
testq %rcx, %rcx
sete %sil
xorl %r10d, %r10d
orb %dl, %sil
jne 0x7ecf
xorl %r10d, %r10d
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x7ec7
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x7eb0
leaq 0x8862(%rip), %rcx      # 0x10738
movq 0x10(%rbx), %rsi
movq (%rcx), %rdi
movq 0x48(%rcx), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: alloc_window_array
static Window *alloc_window_array(void) {
	unsigned count = 0;
	for (struct list *iter = clients_mapping_order; iter; iter = iter->next) {
		count++;
	}
	if (count == 0) count++;
	// Round up to next block of 128
	count = (count + 127) & ~127;
	window_array = realloc(window_array, count * sizeof(Window));
	return window_array;
}

// Assembly:
pushq %rax
leaq 0x881b(%rip), %rax      # 0x10720
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq (%rax), %rax
incl %esi
testq %rax, %rax
jne 0x7f0a
cmpl $0x1, %esi
adcl $0x7f, %esi
andl $-0x80, %esi
movq 0x89bc(%rip), %rdi      # 0x108e0
shlq $0x3, %rsi
callq 0x46c0
movq %rax, 0x89ac(%rip)      # 0x108e0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list_stacking
void ewmh_set_net_client_list_stacking(struct screen *s) {
	Window *windows = alloc_window_array();
	int i = 0;
	if (windows) {
		for (struct list *iter = clients_stacking_order; iter; iter = iter->next) {
			struct client *c = iter->data;
			if (c->screen == s) {
				windows[i++] = c->window;
			}
		}
	}
	XChangeProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST_STACKING),
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7efd
testq %rax, %rax
sete %dl
leaq 0x87dc(%rip), %rcx      # 0x10728
movq (%rcx), %rcx
testq %rcx, %rcx
sete %sil
xorl %r10d, %r10d
orb %dl, %sil
jne 0x7f80
xorl %r10d, %r10d
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x7f78
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x7f61
leaq 0x87b1(%rip), %rcx      # 0x10738
movq 0x10(%rbx), %rsi
movq (%rcx), %rdi
movq 0x50(%rcx), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_allowed_actions
void ewmh_set_allowed_actions(struct client *c) {
	Atom allowed_actions[] = {
		X_ATOM(_NET_WM_ACTION_MOVE),
		X_ATOM(_NET_WM_ACTION_MAXIMIZE_HORZ),
		X_ATOM(_NET_WM_ACTION_MAXIMIZE_VERT),
		X_ATOM(_NET_WM_ACTION_FULLSCREEN),
		X_ATOM(_NET_WM_ACTION_CHANGE_DESKTOP),
		X_ATOM(_NET_WM_ACTION_CLOSE),
		// nelements reduced to omit this if not possible:
		X_ATOM(_NET_WM_ACTION_RESIZE),
	};
	int nelements = sizeof(allowed_actions) / sizeof(Atom);
	// Omit resize element if resizing not possible:
	if (c->max_width && c->max_width == c->min_width
			&& c->max_height && c->max_height == c->min_height)
		nelements--;
	XChangeProperty(display.dpy, c->window, X_ATOM(_NET_WM_ALLOWED_ACTIONS),
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&allowed_actions,
			nelements);
	// As this function is only called when creating a client, take this
	// opportunity to set any initial state on its window.  In particular,
	// I'm interested in docks immediately getting focussed state.
	ewmh_set_net_wm_state(c);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8742(%rip), %rax      # 0x10738
movq 0x118(%rax), %rcx
movq 0x120(%rax), %rdx
movq %rcx, (%rsp)
movq 0x128(%rax), %rcx
movq %rcx, 0x8(%rsp)
movups 0x130(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movups 0x140(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x74(%rdi), %ecx
movl $0x7, %r10d
testl %ecx, %ecx
je 0x8058
cmpl 0x6c(%rbx), %ecx
jne 0x8058
movl 0x78(%rbx), %ecx
testl %ecx, %ecx
je 0x8058
xorl %r10d, %r10d
cmpl 0x70(%rbx), %ecx
sete %r10b
xorl $0x7, %r10d
movq (%rbx), %rsi
movq (%rax), %rdi
movq 0x110(%rax), %rdx
movq %rsp, %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x8090
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_net_wm_state
void ewmh_set_net_wm_state(struct client *c) {
	Atom state[4];
	int i = 0;
	if (c->oldh)
		state[i++] = X_ATOM(_NET_WM_STATE_MAXIMIZED_VERT);
	if (c->oldw)
		state[i++] = X_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ);
	if (c->oldh && c->oldw)
		state[i++] = X_ATOM(_NET_WM_STATE_FULLSCREEN);
	if (c == current || c->is_dock)
		state[i++] = X_ATOM(_NET_WM_STATE_FOCUSED);
	if (c == current) {
		if (c->screen->active != c->window) {
			XChangeProperty(display.dpy, c->screen->root,
			                X_ATOM(_NET_ACTIVE_WINDOW),
			                XA_WINDOW, 32, PropModeReplace,
			                (unsigned char *)&c->window, 1);
			c->screen->active = c->window;
		}
	} else if (c->screen->active == c->window) {
		Window w = None;
		XChangeProperty(display.dpy, c->screen->root, X_ATOM(_NET_ACTIVE_WINDOW),
		                XA_WINDOW, 32, PropModeReplace,
		                (unsigned char *)&w, 1);
		c->screen->active = None;
	}
	XChangeProperty(display.dpy, c->window, X_ATOM(_NET_WM_STATE),
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&state, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x4c(%rdi), %eax
testl %eax, %eax
je 0x80bd
leaq 0x868e(%rip), %rcx      # 0x10738
movq 0xe8(%rcx), %rcx
movq %rcx, (%rsp)
movl $0x1, %r14d
jmp 0x80c0
xorl %r14d, %r14d
movl 0x48(%rbx), %ecx
testl %ecx, %ecx
je 0x80df
leaq 0x866a(%rip), %rdx      # 0x10738
movq 0xf0(%rdx), %rdx
movl %r14d, %esi
incl %r14d
movq %rdx, (%rsp,%rsi,8)
testl %ecx, %ecx
sete %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x8105
leaq 0x8644(%rip), %rax      # 0x10738
movq 0x100(%rax), %rax
movl %r14d, %ecx
incl %r14d
movq %rax, (%rsp,%rcx,8)
leaq 0x8624(%rip), %rax      # 0x10730
movq (%rax), %rax
cmpq %rbx, %rax
je 0x811d
cmpl $0x0, 0x94(%rbx)
je 0x8135
leaq 0x8614(%rip), %rcx      # 0x10738
movq 0x108(%rcx), %rcx
movl %r14d, %edx
incl %r14d
movq %rcx, (%rsp,%rdx,8)
movq (%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x20(%rcx), %rsi
cmpq %rbx, %rax
je 0x818b
cmpq %rdx, %rsi
jne 0x81c7
xorl %r15d, %r15d
leaq 0x28(%rsp), %rax
movq %r15, (%rax)
leaq 0x85dc(%rip), %rdx      # 0x10738
movq 0x10(%rcx), %rsi
movq (%rdx), %rdi
movq 0x78(%rdx), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x4640
addq $0x10, %rsp
movq 0x10(%rbx), %rax
movq %r15, 0x20(%rax)
jmp 0x81c7
cmpq %rdx, %rsi
je 0x81c7
leaq 0x85a1(%rip), %rax      # 0x10738
movq 0x10(%rcx), %rsi
movq (%rax), %rdi
movq 0x78(%rax), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rbx
callq 0x4640
addq $0x10, %rsp
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x20(%rcx)
leaq 0x856a(%rip), %rax      # 0x10738
movq (%rbx), %rsi
movq (%rax), %rdi
movq 0xe0(%rax), %rdx
movq %rsp, %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %rax
callq 0x4640
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/ewmh.c
// Function: ewmh_get_net_wm_window_type
unsigned ewmh_get_net_wm_window_type(Window w) {
	Atom *aprop;
	unsigned long nitems, i;
	unsigned type = 0;
	if ( (aprop = get_property(w, X_ATOM(_NET_WM_WINDOW_TYPE), XA_ATOM, &nitems)) ) {
		for (i = 0; i < nitems; i++) {
			if (aprop[i] == X_ATOM(_NET_WM_WINDOW_TYPE_DESKTOP))
				type |= EWMH_WINDOW_TYPE_DESKTOP;
			if (aprop[i] == X_ATOM(_NET_WM_WINDOW_TYPE_DOCK))
				type |= EWMH_WINDOW_TYPE_DOCK;
			if (aprop[i] == X_ATOM(_NET_WM_WINDOW_TYPE_NOTIFICATION))
				type |= EWMH_WINDOW_TYPE_NOTIFICATION;
		}
		XFree(aprop);
	}
	return type;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x84a1(%rip), %rbx      # 0x10738
movq 0xc0(%rbx), %rsi
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x990d
testq %rax, %rax
je 0x830c
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x8310
movq 0xc8(%rbx), %rdx
movq 0xd0(%rbx), %rsi
movq 0xd8(%rbx), %rdi
xorl %ebx, %ebx
xorl %r8d, %r8d
movq (%rax,%r8,8), %r9
xorl %r10d, %r10d
cmpq %rdx, %r9
sete %r10b
orl %ebx, %r10d
movl %r10d, %r11d
orl $0x2, %r11d
cmpq %rsi, %r9
cmovnel %r10d, %r11d
movl %r11d, %ebx
orl $0x4, %ebx
cmpq %rdi, %r9
cmovnel %r11d, %ebx
incq %r8
cmpq %r8, %rcx
jne 0x82d6
jmp 0x8312
xorl %ebx, %ebx
jmp 0x831a
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x4050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/func.c
// Function: func_move
void func_move(void *sptr, XEvent *e, unsigned flags) {
	struct client *c = sptr;
	if (!(flags & FL_CLIENT) || !c)
		return;

	struct monitor *monitor = client_monitor(c, NULL);
	int width_inc = (c->width_inc > 1) ? c->width_inc : 16;
	int height_inc = (c->height_inc > 1) ? c->height_inc : 16;

	if (e->type == ButtonPress) {
		XButtonEvent *xbutton = (XButtonEvent *)e;
		client_move_drag(c, xbutton->button);
		return;
	}

	if (flags & FL_RELATIVE) {
		if (flags & FL_RIGHT) {
			c->x += width_inc;
		}
		if (flags & FL_LEFT) {
			c->x -= width_inc;
		}
		if (flags & FL_DOWN) {
			c->y += height_inc;
		}
		if (flags & FL_UP) {
			c->y -= height_inc;
		}
	} else {
		if (flags & FL_RIGHT) {
			c->x = monitor->x + monitor->width - c->width-c->border;
		}
		if (flags & FL_LEFT) {
			c->x = monitor->x + c->border;
		}
		if (flags & FL_BOTTOM) {
			c->y = monitor->y + monitor->height - c->height-c->border;
		}
		if (flags & FL_TOP) {
			c->y = monitor->y + c->border;
		}
	}

	do_client_move(c);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
btl $0x10, %edx
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x840a
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x53e4
movl 0x7c(%rbx), %edx
movl 0x80(%rbx), %esi
cmpl $0x2, %edx
movl $0x10, %ecx
cmovll %ecx, %edx
cmpl $0x2, %esi
cmovgel %esi, %ecx
cmpl $0x4, (%r14)
jne 0x840f
movl 0x54(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x629f
popq %rbx
popq %r14
popq %rbp
retq
btl $0xe, %ebp
jb 0x8461
btl $0xb, %ebp
jae 0x842b
movl 0x8(%rax), %ecx
movl 0x30(%rbx), %edx
addl (%rax), %ecx
addl 0x3c(%rbx), %edx
subl %edx, %ecx
movl %ecx, 0x28(%rbx)
btl $0xa, %ebp
jae 0x8439
movl 0x3c(%rbx), %ecx
addl (%rax), %ecx
movl %ecx, 0x28(%rbx)
btl $0xd, %ebp
jae 0x8450
movl 0xc(%rax), %ecx
movl 0x34(%rbx), %edx
addl 0x4(%rax), %ecx
addl 0x3c(%rbx), %edx
subl %edx, %ecx
movl %ecx, 0x2c(%rbx)
btl $0xc, %ebp
jae 0x8485
movl 0x3c(%rbx), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x2c(%rbx)
jmp 0x8485
btl $0xb, %ebp
jae 0x846a
addl %edx, 0x28(%rbx)
btl $0xa, %ebp
jae 0x8473
subl %edx, 0x28(%rbx)
btl $0x9, %ebp
jae 0x847c
addl %ecx, 0x2c(%rbx)
btl $0x8, %ebp
jae 0x8485
subl %ecx, 0x2c(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x848e
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/func.c
// Function: do_client_move
static void do_client_move(struct client *c) {
	if (abs(c->x) == c->border && c->oldw != 0)
		c->x = 0;
	if (abs(c->y) == c->border && c->oldh != 0)
		c->y = 0;
	if (c->width < c->min_width) {
		c->width = c->min_width;
	}
	if (c->max_width && c->width > c->max_width) {
		c->width = c->max_width;
	}
	if (c->height < c->min_height) {
		c->height = c->min_height;
	}
	if (c->max_height && c->height > c->max_height) {
		c->height = c->max_height;
	}
	client_moveresizeraise(c);
#ifdef WARP_POINTER
	setmouse(c->window, c->width + c->border - 1, c->height + c->border - 1);
#endif
	discard_enter_events(c);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %ecx
movl 0x3c(%rdi), %eax
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl %eax, %edx
jne 0x84b0
cmpl $0x0, 0x48(%rbx)
je 0x84b0
movl $0x0, 0x28(%rbx)
movl 0x2c(%rbx), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl %eax, %edx
jne 0x84cb
cmpl $0x0, 0x4c(%rbx)
je 0x84cb
movl $0x0, 0x2c(%rbx)
movl 0x6c(%rbx), %eax
cmpl %eax, 0x30(%rbx)
jge 0x84d6
movl %eax, 0x30(%rbx)
movl 0x74(%rbx), %eax
testl %eax, %eax
je 0x84e5
cmpl %eax, 0x30(%rbx)
jle 0x84e5
movl %eax, 0x30(%rbx)
movl 0x70(%rbx), %eax
cmpl %eax, 0x34(%rbx)
jge 0x84f0
movl %eax, 0x34(%rbx)
movl 0x78(%rbx), %eax
testl %eax, %eax
je 0x84ff
cmpl %eax, 0x34(%rbx)
jle 0x84ff
movl %eax, 0x34(%rbx)
movq %rbx, %rdi
callq 0x628d
movq %rbx, %rdi
popq %rbx
jmp 0x9ac4
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/func.c
// Function: func_next
void func_next(void *sptr, XEvent *e, unsigned flags) {
	(void)sptr;
	(void)flags;
	if (e->type != KeyPress)
		return;
	XKeyEvent *xkey = (XKeyEvent *)e;
	client_select_next();
	if (XGrabKeyboard(display.dpy, xkey->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) {
		XEvent ev;
		do {
			XMaskEvent(display.dpy, KeyPressMask|KeyReleaseMask, &ev);
			if (ev.type == KeyPress && ev.xkey.keycode == xkey->keycode)
				client_select_next();
		} while (ev.type == KeyPress || ev.xkey.keycode == xkey->keycode);
		XUngrabKeyboard(display.dpy, CurrentTime);
	}
	clients_tab_order = list_to_head(clients_tab_order, current);
}

// Assembly:
cmpl $0x2, (%rsi)
jne 0x85bc
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
callq 0x6b65
leaq 0x8204(%rip), %r15      # 0x10738
movq (%r15), %rdi
movq 0x28(%rbx), %rsi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x45e0
testl %eax, %eax
jne 0x8594
movq %rsp, %r14
movq (%r15), %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x4510
cmpl $0x2, (%rsp)
jne 0x857b
movl 0x54(%rsp), %eax
cmpl 0x54(%rbx), %eax
jne 0x857b
callq 0x6b65
cmpl $0x2, (%rsp)
je 0x8557
movl 0x54(%rsp), %eax
cmpl 0x54(%rbx), %eax
je 0x8557
movq (%r15), %rdi
xorl %esi, %esi
callq 0x4450
leaq 0x817d(%rip), %rbx      # 0x10718
movq (%rbx), %rdi
leaq 0x818b(%rip), %rax      # 0x10730
movq (%rax), %rsi
callq 0x8807
movq %rax, (%rbx)
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/func.c
// Function: func_resize
void func_resize(void *sptr, XEvent *e, unsigned flags) {
	struct client *c = sptr;
	if (!(flags & FL_CLIENT) || !c)
		return;

	int width_inc = (c->width_inc > 1) ? c->width_inc : 16;
	int height_inc = (c->height_inc > 1) ? c->height_inc : 16;

	if (e->type == ButtonPress) {
		XButtonEvent *xbutton = (XButtonEvent *)e;
		client_resize_sweep(c, xbutton->button);
		return;
	}

	if (flags & FL_RELATIVE) {
		if (flags & FL_RIGHT) {
			c->width += width_inc;
		}
		if (flags & FL_LEFT) {
			c->width -= width_inc;
		}
		if (flags & FL_DOWN) {
			c->height += height_inc;
		}
		if (flags & FL_UP) {
			c->height -= height_inc;
		}
	} else if (flags & FL_TOGGLE) {
		int hv = 0;
		if ((flags & FL_HORZ) == FL_HORZ) {
			hv |= MAXIMISE_HORZ;
		}
		if ((flags & FL_VERT) == FL_VERT) {
			hv |= MAXIMISE_VERT;
		}
		client_maximise(c, NET_WM_STATE_TOGGLE, hv);
		return;
	}

	do_client_move(c);
}

// Assembly:
btl $0x10, %edx
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x860e
movl 0x7c(%rdi), %ecx
movl 0x80(%rdi), %r8d
cmpl $0x2, %ecx
movl $0x10, %eax
cmovll %eax, %ecx
cmpl $0x2, %r8d
cmovgel %r8d, %eax
cmpl $0x4, (%rsi)
jne 0x860f
movl 0x54(%rsi), %esi
jmp 0x5efc
retq
btl $0xe, %edx
jb 0x8620
btl $0x12, %edx
jb 0x864d
jmp 0x848e
btl $0xb, %edx
jae 0x8629
addl %ecx, 0x30(%rdi)
btl $0xa, %edx
jae 0x8632
subl %ecx, 0x30(%rdi)
btl $0x9, %edx
jae 0x863b
addl %eax, 0x34(%rdi)
btl $0x8, %edx
jae 0x848e
subl %eax, 0x34(%rdi)
jmp 0x848e
notl %edx
xorl %ecx, %ecx
testl $0xc00, %edx            # imm = 0xC00
sete %cl
leal 0x2(%rcx), %eax
testl $0x3000, %edx           # imm = 0x3000
cmovnel %ecx, %eax
movl $0x2, %esi
movl %eax, %edx
jmp 0x6957
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/func.c
// Function: func_vdesk
void func_vdesk(void *sptr, XEvent *e, unsigned flags) {
	(void)e;
	if (flags & FL_CLIENT) {
		struct client *c = sptr;
		if (flags & FL_TOGGLE) {
			if (is_fixed(c)) {
				client_to_vdesk(c, c->screen->vdesk);
			} else {
				client_to_vdesk(c, VDESK_FIXED);
			}
		}
	} else if (flags & FL_SCREEN) {
		struct screen *current_screen = sptr;
		if (flags & FL_TOGGLE) {
			switch_vdesk(current_screen, current_screen->old_vdesk);
		} else if (flags & FL_RELATIVE) {
			if (flags & FL_DOWN) {
				if (current_screen->vdesk > 0) {
					switch_vdesk(current_screen, current_screen->vdesk - 1);
				}
			}
			if (flags & FL_UP) {
				if (current_screen->vdesk < VDESK_MAX) {
					switch_vdesk(current_screen, current_screen->vdesk + 1);
				}
			}
		} else {
			int v = flags & FL_VALUEMASK;
			switch_vdesk(current_screen, v);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
btl $0x10, %edx
jb 0x86a7
testw %bp, %bp
jns 0x86ad
btl $0x12, %ebp
jb 0x86c4
btl $0xe, %ebp
jb 0x86ea
movzbl %bpl, %esi
jmp 0x86c7
btl $0x12, %ebp
jb 0x86b4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $-0x1, 0x20(%rbx)
je 0x86d5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jmp 0x86df
movl 0x64(%rbx), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x946e
movq 0x10(%rbx), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x590e
btl $0x9, %ebp
jae 0x8701
movl 0x60(%rbx), %esi
testl %esi, %esi
je 0x8701
decl %esi
movq %rbx, %rdi
callq 0x946e
btl $0x8, %ebp
jae 0x86ad
movl 0x60(%rbx), %esi
leaq 0x81ef(%rip), %rax      # 0x10900
movl 0x2c(%rax), %eax
decl %eax
cmpl %eax, %esi
jae 0x86ad
incl %esi
jmp 0x86c7
nop
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/list.c
// Function: list_insert_before
struct list *list_insert_before(struct list *list, struct list *before, void *data) {
	struct list *elem = list_new(data);
	if (!elem)
		return list;
	if (!list)
		return elem;
	elem->next = before;
	if (before == list)
		return elem;
	for (struct list *iter = list; iter; iter = iter->next) {
		if (iter->next == before) {
			iter->next = elem;
			return list;
		}
		if (!iter->next) {
			elem->next = NULL;
			iter->next = elem;
			return list;
		}
	}
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x41e0
testq %rax, %rax
je 0x874a
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
jmp 0x874c
xorl %eax, %eax
testq %rax, %rax
je 0x8780
testq %rbx, %rbx
je 0x877d
movq %r14, (%rax)
cmpq %rbx, %r14
je 0x877d
movq %rbx, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
cmpq %r14, %rdx
je 0x8778
testq %rdx, %rdx
jne 0x8761
movq $0x0, (%rax)
movq %rax, (%rcx)
jmp 0x8780
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/list.c
// Function: list_delete
struct list *list_delete(struct list *list, void *data) {
	if (!data)
		return list;
	for (struct list **elemp = &list; *elemp; elemp = &(*elemp)->next) {
		if ((*elemp)->data == data) {
			struct list *elem = *elemp;
			*elemp = elem->next;
			free(elem);
			break;
		}
	}
	return list;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x8805
movq %rsp, %rdi
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x8801
cmpq %rsi, 0x8(%rdi)
jne 0x87e5
movq (%rdi), %rcx
movq %rcx, (%rax)
callq 0x42d0
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/list.c
// Function: list_to_head
struct list *list_to_head(struct list *list, void *data) {
	if (!data)
		return list;
	list = list_delete(list, data);
	return list_prepend(list, data);
}

// Assembly:
movq %rdi, %rax
testq %rsi, %rsi
je 0x8858
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rax, %rdi
callq 0x87d5
movq %rax, %rbx
movl $0x10, %edi
callq 0x41e0
testq %rax, %rax
je 0x883d
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
jmp 0x883f
xorl %eax, %eax
testq %rax, %rax
je 0x884e
testq %rbx, %rbx
je 0x8851
movq %rbx, (%rax)
jmp 0x8851
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/list.c
// Function: list_find
struct list *list_find(struct list *list, void *data) {
	for (struct list *elem = list; elem; elem = elem->next) {
		if (elem->data == data)
			return elem;
	}
	return NULL;
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
je 0x888f
cmpq %rsi, 0x8(%rax)
je 0x888f
movq (%rax), %rax
testq %rax, %rax
jne 0x8881
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/main.c
// Function: set_bind
static void set_bind(const char *arg) {
	char *argdup = xstrdup(arg);
	if (!argdup)
		return;
	opt_bind = list_prepend(opt_bind, argdup);
}

// Assembly:
pushq %rax
callq 0xa128
testq %rax, %rax
je 0x8c54
movq 0x7d1b(%rip), %rdi      # 0x10960
movq %rax, %rsi
callq 0x8789
movq %rax, 0x7d0c(%rip)      # 0x10960
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/main.c
// Function: set_app
static void set_app(const char *arg) {
	struct application *new = xmalloc(sizeof(struct application));
	char *tmp;
	new->res_name = new->res_class = NULL;
	new->geometry_mask = 0;
	new->is_dock = 0;
	new->vdesk = VDESK_NONE;
	if ((tmp = strchr(arg, '/'))) {
		*(tmp++) = 0;
	}
	if (*arg) {
		new->res_name = xstrdup(arg);
	}
	if (tmp && *tmp) {
		new->res_class = xstrdup(tmp);
	}
	applications = list_prepend(applications, new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0xa0b0
movq %rax, %rbx
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
movq %rax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movq %r14, %rdi
movl $0x2f, %esi
callq 0x4480
testq %rax, %rax
je 0x8ca3
movq %rax, %r15
incq %r15
movb $0x0, (%rax)
jmp 0x8ca6
xorl %r15d, %r15d
cmpb $0x0, (%r14)
je 0x8cb7
movq %r14, %rdi
callq 0xa128
movq %rax, (%rbx)
testq %r15, %r15
je 0x8cce
cmpb $0x0, (%r15)
je 0x8cce
movq %r15, %rdi
callq 0xa128
movq %rax, 0x8(%rbx)
movq 0x7c1b(%rip), %rdi      # 0x108f0
movq %rbx, %rsi
callq 0x8789
movq %rax, 0x7c0c(%rip)      # 0x108f0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/main.c
// Function: set_app_geometry
static void set_app_geometry(const char *arg) {
	if (applications) {
		struct application *app = applications->data;
		app->geometry_mask = XParseGeometry(arg,
				&app->x, &app->y, &app->width, &app->height);
	}
}

// Assembly:
movq 0x7bff(%rip), %rax      # 0x108f0
testq %rax, %rax
je 0x8d14
pushq %rbx
movq 0x8(%rax), %rbx
leaq 0x14(%rbx), %rsi
leaq 0x18(%rbx), %rdx
leaq 0x1c(%rbx), %rcx
leaq 0x20(%rbx), %r8
callq 0x47a0
movl %eax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mati75[P]evilwm/main.c
// Function: set_app_vdesk
static void set_app_vdesk(const char *arg) {
	unsigned v = strtoul(arg, NULL, 0);
	if (applications && valid_vdesk(v)) {
		struct application *app = applications->data;
		app->vdesk = v;
	}
}

// Assembly:
pushq %rax
xorl %esi, %esi
xorl %edx, %edx
callq 0x4730
movq 0x7bb2(%rip), %rcx      # 0x108f0
testq %rcx, %rcx
je 0x8d57
cmpl $-0x1, %eax
je 0x8d50
cmpl %eax, 0x7bde(%rip)      # 0x1092c
jbe 0x8d57
movq 0x8(%rcx), %rcx
movl %eax, 0x28(%rcx)
popq %rax
retq