LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd06d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4400
movq 0xd046(%rip), %rdi      # 0x12d70
movq -0x8(%rbp), %rsi
callq 0xb020
movq %rax, 0xd036(%rip)      # 0x12d70
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9ea0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x4080
movl $0x16, -0xc8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x94(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x90(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x8c(%rbp)
leaq 0xcfad(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0xc8(%rbp), %r8
callq 0x4530
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0x5e44
movq -0x20(%rbp), %rax
leaq 0x85b9(%rip), %rcx      # 0xe3f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5e46
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5eaa
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5eaa
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5eaa
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x5eaa
jmp 0x5eaa
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x5eaa
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5eaa
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5eaa
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x5ee3
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
leaq 0xcebe(%rip), %rcx      # 0x12d80
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
je 0x5ef0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x5f29
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
leaq 0xce78(%rip), %rcx      # 0x12d80
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl 0x1c(%rcx), %eax
je 0x5f36
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xce25(%rip), %rax      # 0x12d78
movq %rax, -0x10(%rbp)
cmpq $0x0, 0xce19(%rip)      # 0x12d78
je 0x5f8a
leaq 0xce18(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq 0xce06(%rip), %rax      # 0x12d78
movq 0x8(%rax), %rsi
movq 0xcdfb(%rip), %rax      # 0x12d78
movq 0x10(%rax), %rax
movq 0x40(%rax), %rdx
callq 0x4320
cmpq $0x0, -0x8(%rbp)
je 0x600e
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x5fad
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5fbd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xcdbc(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x4320
leaq 0xcda1(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x45a0
leaq 0xcd8a(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x44d0
movq -0x8(%rbp), %rax
movq %rax, 0xcd5f(%rip)      # 0x12d78
cmpq $0x0, -0x10(%rbp)
je 0x6029
movq -0x10(%rbp), %rdi
callq 0xa0f0
cmpq $0x0, -0x8(%rbp)
je 0x6039
movq -0x8(%rbp), %rdi
callq 0xa0f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x6064
movl -0xc(%rbp), %eax
leaq 0xcee9(%rip), %rcx      # 0x12f48
cmpl 0x2c(%rcx), %eax
jae 0x60b5
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x60(%rcx), %eax
je 0x608c
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x6097
movq -0x8(%rbp), %rdi
callq 0x5c70
jmp 0x60a0
movq -0x8(%rbp), %rdi
callq 0x5bb0
movq -0x8(%rbp), %rdi
callq 0xa3a0
movq 0xccc8(%rip), %rdi      # 0x12d78
callq 0x5f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6351
leaq 0xca8d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x46b0
cmpl $0x0, %eax
je 0x6351
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6348
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0xca4f(%rip), %rcx      # 0x12d80
cmpq 0x18(%rcx), %rax
jne 0x633b
movb $0x1, -0xd(%rbp)
jmp 0x633d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6316
movq -0x20(%rbp), %rdi
callq 0x4050
testb $0x1, -0xd(%rbp)
je 0x63d5
leaq -0xe8(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x4080
movl $0x21, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
leaq 0xc9f7(%rip), %rax      # 0x12d80
movq 0x10(%rax), %rax
movq %rax, -0xc0(%rbp)
movl $0x20, -0xb8(%rbp)
leaq 0xc9db(%rip), %rax      # 0x12d80
movq 0x18(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq 0xc9c9(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xe8(%rbp), %r8
callq 0x4530
jmp 0x63eb
leaq 0xc9a4(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4780
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc96d(%rip), %rax      # 0x12d80
cmpl $0x0, 0x178(%rax)
jne 0x6421
jmp 0x64ae
leaq 0xc958(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0xc(%rbp), %rdx
leaq -0x14(%rbp), %r10
leaq -0x18(%rbp), %rax
leaq -0x10(%rbp), %r11
movq %r10, %rcx
movq %r10, %r8
movq %rax, %r9
movq %rax, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x43f0
cmpl $0x0, %eax
je 0x64ae
cmpl $0x0, -0xc(%rbp)
je 0x64ae
leaq 0xc901(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %r9
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x4710
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc8ad(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %r10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
movl $0x2, %r9d
xorl %edx, %edx
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4280
movq %rax, %rcx
leaq 0xc854(%rip), %rax      # 0x12d80
movq %rcx, 0x198(%rax)
leaq 0xc846(%rip), %rax      # 0x12d80
movq (%rax), %rdi
leaq 0xc83c(%rip), %rax      # 0x12d80
movq 0x198(%rax), %rsi
callq 0x46f0
movq -0x8(%rbp), %rdi
callq 0x6560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x771d
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0xb693(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %ecx
callq 0x45f0
cmpl $0x0, %eax
je 0x771b
jmp 0x7842
jmp 0x777a
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0xb652(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x4230
cmpl $0x0, %eax
je 0x7778
jmp 0x7842
jmp 0x777a
movq -0x8(%rbp), %rdi
callq 0x64c0
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x77dd
leaq 0xb5ed(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl $0x2, %esi
leaq -0xd8(%rbp), %rdx
callq 0x4520
movl -0x84(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x77b4
jmp 0x7783
leaq 0xb5c5(%rip), %rax      # 0x12d80
movq (%rax), %rdi
leaq -0xd8(%rbp), %rcx
leaq 0x84(%rip), %rdx        # 0x7850
movq %rcx, %rsi
callq 0x4560
cmpl $0x0, %eax
je 0x77db
jmp 0x7783
jmp 0x780a
leaq 0xb59c(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl $0x8, %esi
leaq -0xd8(%rbp), %rdx
callq 0x4520
movl -0x84(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x7808
jmp 0x7783
jmp 0x780a
jmp 0x780c
callq 0x6940
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x782f
leaq 0xb55f(%rip), %rax      # 0x12d80
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4460
jmp 0x7842
leaq 0xb54a(%rip), %rax      # 0x12d80
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41c0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x787a
movl $0x0, -0x4(%rbp)
jmp 0x78ae
movq -0x28(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x54(%rcx), %eax
je 0x7893
movl $0x0, -0x4(%rbp)
jmp 0x78ae
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb4ad(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
subl 0x3c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x3c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x34(%rax), %r9d
callq 0x43c0
leaq 0xb46a(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x34(%rax), %r9d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x43c0
movq -0x8(%rbp), %rdi
callq 0x5d50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xb071(%rip), %rax      # 0x12d60
movq (%rax), %rdi
leaq 0xb07f(%rip), %rax      # 0x12d78
movq (%rax), %rsi
callq 0xb0c0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7d32
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7d30
leaq 0xb053(%rip), %rax      # 0x12d78
cmpq $0x0, (%rax)
jne 0x7d30
jmp 0x7dfd
jmp 0x7d32
cmpq $0x0, -0x8(%rbp)
jne 0x7d47
leaq 0xb020(%rip), %rax      # 0x12d60
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7d53
jmp 0x7dfd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb00e(%rip), %rcx      # 0x12d78
cmpq (%rcx), %rax
jne 0x7d74
jmp 0x7dfd
jmp 0x7d76
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0x7d99
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movb $0x1, %al
cmpl 0x60(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x7dc5
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x94(%rcx)
movb %al, -0x12(%rbp)
je 0x7dbf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x68(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7d05
cmpq $0x0, -0x10(%rbp)
jne 0x7dd9
jmp 0x7dfd
movq -0x10(%rbp), %rdi
callq 0x5c70
movq -0x10(%rbp), %rdi
callq 0x5cb0
movq -0x10(%rbp), %rdi
callq 0x5f40
movq -0x10(%rbp), %rdi
callq 0xcfa0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xa121(%rip), %rdi      # 0x12d80
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x44d0
cmpq $0x0, 0xa266(%rip)      # 0x12ee0
je 0x8c8f
movq 0xa0fd(%rip), %rdi      # 0x12d80
movq 0xa256(%rip), %rsi      # 0x12ee0
callq 0x4180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xa269(%rip), %eax      # 0x12f08
jge 0x8d30
movq 0xa264(%rip), %rdi      # 0x12f10
movslq -0x4(%rbp), %rax
imulq $0x78, %rax, %rax
addq %rax, %rdi
callq 0xc400
movq 0xa0bd(%rip), %rdi      # 0x12d80
movq 0xa246(%rip), %rax      # 0x12f10
movslq -0x4(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rsi
callq 0x43a0
movq 0xa09b(%rip), %rdi      # 0x12d80
movq 0xa094(%rip), %rax      # 0x12d80
movq 0xe8(%rax), %rax
movslq -0x4(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rsi
callq 0x45a0
movq 0xa202(%rip), %rax      # 0x12f10
movslq -0x4(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x42e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8c96
movq 0xa1d9(%rip), %rdi      # 0x12f10
callq 0x42e0
movq 0xa03d(%rip), %rdi      # 0x12d80
callq 0x4340
movq $0x0, 0xa02d(%rip) # 0x12d80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xa18d(%rip), %eax      # 0x12f08
jge 0x8e2c
movq 0xa188(%rip), %rax      # 0x12f10
movslq -0x4(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0x9fe2(%rip), %rdi      # 0x12d80
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x14(%rbp), %r9
callq 0x4740
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8e15
movq 0x9faf(%rip), %rdi      # 0x12d80
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x4640
cmpl $0x0, -0x48(%rbp)
jne 0x8e08
cmpl $0x2, -0x64(%rbp)
jne 0x8e08
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e50
jmp 0x8e0a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8dc2
movq -0x30(%rbp), %rdi
callq 0x4050
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8d72
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_configure_notify
static void handle_configure_notify(XConfigureEvent *e) {
	struct client *c = find_client(e->window);
	if (!c) {
		LOG_XDEBUG("handle_configure_notify() on unmanaged window\n");
		return;
	}
	LOG_XENTER("handle_configure_notify(window=%lx, parent=%lx)", c->window, c->parent);
	LOG_XDEBUG("x,y w,h=%d,%d %d,%d\n", e->x, e->y, e->width, e->height);
	LOG_XDEBUG("bw=%d\n", e->border_width);
	LOG_XDEBUG("above=%lx\n", (unsigned long)e->above);
	LOG_XDEBUG("override_redirect=%d\n", (int)e->override_redirect);
	LOG_XLEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x90a6
jmp 0x90a6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_configure_request
static void handle_configure_request(XConfigureRequestEvent *e) {
	struct client *c = find_client(e->window);

	XWindowChanges wc;
	wc.x = e->x;
	wc.y = e->y;
	wc.width = e->width;
	wc.height = e->height;
	wc.border_width = 0;
	wc.sibling = e->above;
	wc.stack_mode = e->detail;

	if (c) {
		if (e->value_mask & CWStackMode && e->value_mask & CWSibling) {
			struct client *sibling = find_client(e->above);
			if (sibling) {
				wc.sibling = sibling->parent;
			}
		}
		do_window_changes(e->value_mask, &wc, c, 0);
		if (c == current) {
			discard_enter_events(c);
		}
	} else {
		LOG_XENTER("XConfigureWindow(window=%lx, value_mask=%lx)", (unsigned long)e->window, e->value_mask);
		XConfigureWindow(display.dpy, e->window, e->value_mask, &wc);
		LOG_XLEAVE();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9197
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x9163
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x9163
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x5820
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x9161
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9163
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rsi
xorl %ecx, %ecx
callq 0x98a0
movq -0x10(%rbp), %rax
leaq 0x9bf1(%rip), %rcx      # 0x12d78
cmpq (%rcx), %rax
jne 0x9195
movq -0x10(%rbp), %rdi
callq 0xcfa0
jmp 0x91bc
leaq 0x9be2(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
leaq -0x38(%rbp), %rcx
callq 0x40e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_map_request
static void handle_map_request(XMapRequestEvent *e) {
	struct client *c = find_client(e->window);

	LOG_ENTER("handle_map_request(window=%lx)", (unsigned long)e->window);
	if (c) {
		if (!is_fixed(c) && c->vdesk != c->screen->vdesk)
			switch_vdesk(c->screen, c->vdesk);
		client_show(c);
		client_raise(c);
	} else {
		XWindowAttributes attr;
		XGetWindowAttributes(display.dpy, e->window, &attr);
		client_manage_new(e->window, find_screen(attr.root));
	}
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x923d
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0x9229
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x60(%rcx), %eax
je 0x9229
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0xc590
movq -0x10(%rbp), %rdi
callq 0x5c70
movq -0x10(%rbp), %rdi
callq 0x5cb0
jmp 0x9282
leaq 0x9b3c(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x98(%rbp), %rdx
callq 0x4640
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rdi
callq 0xca10
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x7e50
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_colormap_change
static void handle_colormap_change(XColormapEvent *e) {
	struct client *c = find_client(e->window);

	if (c && e->new) {
		c->cmap = e->colormap;
		XInstallColormap(display.dpy, c->cmap);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x92e5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x92e5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x9aab(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_enter_event
static void handle_enter_event(XCrossingEvent *e) {
	struct client *c;

	if ((c = find_client(e->window))) {
		if (!is_fixed(c) && c->vdesk != c->screen->vdesk)
			return;
		select_client(c);
		clients_tab_order = list_to_head(clients_tab_order, c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x935c
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0x9333
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x60(%rcx), %eax
je 0x9333
jmp 0x935c
movq -0x10(%rbp), %rdi
callq 0x5f40
leaq 0x9a1d(%rip), %rax      # 0x12d60
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb020
movq %rax, %rcx
leaq 0x9a07(%rip), %rax      # 0x12d60
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_property_change
static void handle_property_change(XPropertyEvent *e) {
	struct client *c = find_client(e->window);

	if (c) {
		LOG_ENTER("handle_property_change(window=%lx, atom=%s)", (unsigned long)e->window, debug_atom_name(e->atom));
		if (e->atom == XA_WM_NORMAL_HINTS) {
			get_wm_normal_hints(c);
			LOG_DEBUG("geometry=%dx%d+%d+%d\n", c->width, c->height, c->x, c->y);
		} else if (e->atom == X_ATOM(_NET_WM_WINDOW_TYPE)) {
			get_window_type(c);
			if (!c->is_dock && (is_fixed(c) || (c->vdesk == c->screen->vdesk))) {
				client_show(c);
			}
		}
		LOG_LEAVE();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9405
movq -0x8(%rbp), %rax
cmpq $0x28, 0x28(%rax)
jne 0x93aa
movq -0x10(%rbp), %rdi
callq 0x5590
jmp 0x9403
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0x99c7(%rip), %rcx      # 0x12d80
cmpq 0xc0(%rcx), %rax
jne 0x9401
movq -0x10(%rbp), %rdi
callq 0x57c0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x94(%rax)
jne 0x93ff
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0x93f6
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x60(%rcx), %eax
jne 0x93ff
movq -0x10(%rbp), %rdi
callq 0x5c70
jmp 0x9401
jmp 0x9403
jmp 0x9405
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_unmap_event
static void handle_unmap_event(XUnmapEvent *e) {
	struct client *c = find_client(e->window);

	LOG_ENTER("handle_unmap_event(window=%lx)", (unsigned long)e->window);
	if (c) {
		if (c->ignore_unmap) {
			c->ignore_unmap--;
			LOG_DEBUG("ignored (%d ignores remaining)\n", c->ignore_unmap);
		} else {
			LOG_DEBUG("flagging client for removal\n");
			c->remove = 1;
			need_client_tidy = 1;
		}
	} else {
		LOG_DEBUG("unknown client!\n");
	}
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5820
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9464
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x944d
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x9462
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x1, 0x9abe(%rip)      # 0x12f20
jmp 0x9466
jmp 0x9466
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_mappingnotify_event
static void handle_mappingnotify_event(XMappingEvent *e) {
	XRefreshKeyboardMapping(e);
	if (e->request == MappingKeyboard) {
		int i;
		for (i = 0; i < display.nscreens; i++) {
			bind_grab_for_screen(&display.screens[i]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4110
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x94d3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x98e0(%rip), %rcx      # 0x12d80
cmpl 0x188(%rcx), %eax
jge 0x94d1
leaq 0x98d1(%rip), %rax      # 0x12d80
movq 0x190(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x78, %rax, %rax
addq %rax, %rdi
callq 0x4fc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9496
jmp 0x94d3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/events.c
// Function: handle_randr_event
static void handle_randr_event(XRRScreenChangeNotifyEvent *e) {
	struct screen *s = find_screen(e->root);
	// Record geometries of clients relative to monitor
	scan_clients_before_resize(s);
	// Update Xlib's idea of screen size
	XRRUpdateConfiguration((XEvent*)e);
	// Scan new monitor list
	screen_probe_monitors(s);
	// Fix any clients that are now not visible on any monitor.  Also
	// adjusts maximised geometries where appropriate.
	fix_screen_after_resize(s);
	// Update various EWMH properties that reflect screen geometry
	ewmh_set_screen_workarea(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xca10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc760
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x10(%rbp), %rdi
callq 0xc160
movq -0x10(%rbp), %rdi
callq 0xc870
movq -0x10(%rbp), %rdi
callq 0x9c10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x914d(%rip), %rax      # 0x12d80
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movslq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x9126(%rip), %rax      # 0x12d80
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movslq 0x1c(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x90ff(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x90ed(%rip), %rax      # 0x12d80
movq 0x60(%rax), %rdx
leaq -0x30(%rbp), %rax
addq $0x10, %rax
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x4650
leaq 0x90bb(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x90a9(%rip), %rax      # 0x12d80
movq 0x68(%rax), %rdx
leaq -0x30(%rbp), %rax
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x4650
leaq 0x907b(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x9069(%rip), %rax      # 0x12d80
movq 0x80(%rax), %rdx
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x30(%rbp), %rax
movq %rax, (%rsp)
movl $0x4, 0x8(%rsp)
callq 0x4650
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x9e20
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9dd0
leaq 0x8fee(%rip), %rax      # 0x12d68
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9dce
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x9dbf
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x9dc1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9d81
jmp 0x9dd0
leaq 0x8fa9(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x8f97(%rip), %rax      # 0x12d80
movq 0x48(%rax), %rdx
movq -0x10(%rbp), %r10
movl -0x14(%rbp), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x4650
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x8f32(%rip), %rax      # 0x12d68
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9e5a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9e3d
cmpl $0x0, -0x4(%rbp)
jne 0x9e69
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x7f, %eax
andl $-0x80, %eax
movl %eax, -0x4(%rbp)
movq 0x90ac(%rip), %rdi      # 0x12f28
movl -0x4(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x46c0
movq %rax, 0x9097(%rip)      # 0x12f28
movq 0x9090(%rip), %rax      # 0x12f28
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x9e20
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9f20
leaq 0x8ea6(%rip), %rax      # 0x12d70
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9f1e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x9f0f
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x9f11
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9ed1
jmp 0x9f20
leaq 0x8e59(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x8e47(%rip), %rax      # 0x12d80
movq 0x50(%rax), %rdx
movq -0x10(%rbp), %r10
movl -0x14(%rbp), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x4650
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x8d9d(%rip), %rax      # 0x12d80
movq 0x118(%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x8d8b(%rip), %rax      # 0x12d80
movq 0x128(%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x8d79(%rip), %rax      # 0x12d80
movq 0x130(%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x8d67(%rip), %rax      # 0x12d80
movq 0x138(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x8d55(%rip), %rax      # 0x12d80
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x8d43(%rip), %rax      # 0x12d80
movq 0x148(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x8d31(%rip), %rax      # 0x12d80
movq 0x120(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x7, -0x44(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x74(%rax)
je 0xa09e
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jne 0xa09e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0xa09e
movq -0x8(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x70(%rcx), %eax
jne 0xa09e
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
leaq 0x8cdb(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x8cca(%rip), %rax      # 0x12d80
movq 0x110(%rax), %rdx
movl -0x44(%rbp), %eax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x40(%rbp), %r10
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x4650
movq -0x8(%rbp), %rdi
callq 0xa0f0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8962(%rip), %rax      # 0x12d80
movq 0xc0(%rax), %rsi
movl $0x4, %edx
leaq -0x18(%rbp), %rcx
callq 0xcd00
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xa4e2
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa4d9
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x8916(%rip), %rcx      # 0x12d80
cmpq 0xc8(%rcx), %rax
jne 0xa47c
movl -0x24(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x88f1(%rip), %rcx      # 0x12d80
cmpq 0xd0(%rcx), %rax
jne 0xa4a1
movl -0x24(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x88cc(%rip), %rcx      # 0x12d80
cmpq 0xd8(%rcx), %rax
jne 0xa4c6
movl -0x24(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0xa4c8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa449
movq -0x10(%rbp), %rdi
callq 0x4050
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_delete
void func_delete(void *sptr, XEvent *e, unsigned flags) {
	if (!(flags & FL_CLIENT))
		return;
	struct client *c = sptr;
	(void)e;
	send_wm_delete(c, flags & FL_VALUEMASK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
jne 0xa582
jmp 0xa59c
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
andl $0xff, %esi
callq 0x62d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_dock
void func_dock(void *sptr, XEvent *e, unsigned flags) {
	if (!(flags & FL_SCREEN))
		return;
	struct screen *current_screen = sptr;
	(void)e;
	if (flags & FL_TOGGLE) {
		set_docks_visible(current_screen, !current_screen->docks_visible);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0xa5d2
jmp 0xa602
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0xa602
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
cmpl $0x0, 0x68(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0xc6b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_info
void func_info(void *sptr, XEvent *e, unsigned flags) {
	if (!(flags & FL_CLIENT))
		return;
	struct client *c = sptr;
	client_show_info(c, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
jne 0xa632
jmp 0xa647
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x76c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)