LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x79f2
xorl %r10d, %r10d
testq %rax, %rax
je 0x79ca
leaq 0x7d67(%rip), %rcx      # 0xf710
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x79ca
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x79a9
movq (%rdx), %rdx
movl %r10d, %esi
incl %r10d
movq %rdx, (%rax,%rsi,8)
jmp 0x79a9
leaq 0x7d57(%rip), %rcx      # 0xf728
movq 0x10(%rbx), %rsi
movq (%rcx), %rdi
movq 0x48(%rcx), %rdx
pushq $0x21
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
popq %rcx
popq %rdx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7d16(%rip), %rax      # 0xf710
pushq $-0x1
popq %rsi
movq (%rax), %rax
incl %esi
testq %rax, %rax
jne 0x79fd
cmpl $0x1, %esi
adcl $0x7f, %esi
andl $-0x80, %esi
movq 0x7eb9(%rip), %rdi      # 0xf8d0
shlq $0x3, %rsi
callq 0x46c0
movq %rax, 0x7ea9(%rip)      # 0xf8d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x79f2
xorl %r10d, %r10d
testq %rax, %rax
je 0x7a62
leaq 0x7cd7(%rip), %rcx      # 0xf718
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x7a62
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x7a41
movq (%rdx), %rdx
movl %r10d, %esi
incl %r10d
movq %rdx, (%rax,%rsi,8)
jmp 0x7a41
leaq 0x7cbf(%rip), %rcx      # 0xf728
movq 0x10(%rbx), %rsi
movq (%rcx), %rdi
movq 0x50(%rcx), %rdx
pushq $0x21
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
popq %rcx
popq %rdx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7c5c(%rip), %rax      # 0xf728
movq 0x118(%rax), %rcx
movq 0x120(%rax), %rdx
movq %rcx, (%rsp)
movups 0x128(%rax), %xmm0
movups %xmm0, 0x8(%rsp)
movups 0x138(%rax), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x148(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x74(%rdi), %ecx
pushq $0x7
popq %r10
testl %ecx, %ecx
je 0x7b2c
cmpl 0x6c(%rbx), %ecx
jne 0x7b2c
movl 0x78(%rbx), %ecx
testl %ecx, %ecx
je 0x7b2c
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
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
popq %rcx
popq %rdx
movq %rbx, %rdi
callq 0x7b5e
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x4c(%rdi)
je 0x7ba2
leaq 0x7bb3(%rip), %rax      # 0xf728
movq 0xe8(%rax), %rcx
movq %rcx, (%rsp)
cmpl $0x0, 0x48(%rbx)
je 0x7bbe
movq 0xf0(%rax), %rcx
movq 0x100(%rax), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
pushq $0x3
jmp 0x7bc0
cmpl $0x0, 0x48(%rbx)
je 0x7cbb
leaq 0x7b75(%rip), %rax      # 0xf728
movq 0xf0(%rax), %rax
movq %rax, (%rsp)
pushq $0x1
popq %r14
leaq 0x7b57(%rip), %rax      # 0xf720
cmpq %rbx, (%rax)
je 0x7c3e
cmpl $0x0, 0x94(%rbx)
je 0x7bef
leaq 0x7b4a(%rip), %rax      # 0xf728
movq 0x108(%rax), %rax
movl %r14d, %ecx
incl %r14d
movq %rax, (%rsp,%rcx,8)
movq (%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rsi, 0x20(%rax)
jne 0x7c8d
leaq 0x20(%rsp), %r10
andq $0x0, (%r10)
leaq 0x7b18(%rip), %rcx      # 0xf728
movq 0x10(%rax), %rsi
movq (%rcx), %rdi
movq 0x78(%rcx), %rdx
pushq $0x21
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %r10
callq 0x4640
popq %rcx
popq %rdx
movq 0x10(%rbx), %rax
andq $0x0, 0x20(%rax)
movq (%rbx), %rsi
jmp 0x7c8d
leaq 0x7ae3(%rip), %rax      # 0xf728
movq 0x108(%rax), %rcx
movl %r14d, %edx
incl %r14d
movq %rcx, (%rsp,%rdx,8)
movq 0x10(%rbx), %rcx
movq 0x20(%rcx), %rsi
cmpq (%rbx), %rsi
je 0x7c8d
movq 0x10(%rcx), %rsi
movq (%rax), %rdi
movq 0x78(%rax), %rdx
pushq $0x21
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %rbx
callq 0x4640
popq %rcx
popq %rdx
movq (%rbx), %rsi
movq 0x10(%rbx), %rax
movq %rsi, 0x20(%rax)
leaq 0x7a94(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq 0xe0(%rax), %rdx
movq %rsp, %rax
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r14
pushq %rax
callq 0x4640
addq $0x38, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x7bc2
// File: /workspace/github_c_makefile_star2_O2/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 0x79d2(%rip), %rbx      # 0xf728
movq 0xc0(%rbx), %rsi
pushq $0x4
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x929b
testq %rax, %rax
je 0x7dce
movq 0x8(%rsp), %rcx
movq 0xc8(%rbx), %rdx
movq 0xd0(%rbx), %rsi
movq 0xd8(%rbx), %rdi
xorl %r8d, %r8d
xorl %ebx, %ebx
cmpq %r8, %rcx
je 0x7dc4
movq (%rax,%r8,8), %r9
xorl %r10d, %r10d
cmpq %rdx, %r9
sete %r10b
orl %r10d, %ebx
movl %ebx, %r10d
orl $0x2, %r10d
cmpq %rsi, %r9
cmovnel %ebx, %r10d
movl %r10d, %ebx
orl $0x4, %ebx
cmpq %rdi, %r9
cmovnel %r10d, %ebx
incq %r8
jmp 0x7d8e
movq %rax, %rdi
callq 0x4050
jmp 0x7dd0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ebc
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x511e
movl 0x7c(%rbx), %edx
movl 0x80(%rbx), %esi
cmpl $0x2, %edx
pushq $0x10
popq %rcx
cmovll %ecx, %edx
cmpl $0x2, %esi
cmovgel %esi, %ecx
cmpl $0x4, (%r14)
jne 0x7ec1
movl 0x54(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5e71
popq %rbx
popq %r14
popq %rbp
retq
btl $0xe, %ebp
jb 0x7f13
btl $0xb, %ebp
jae 0x7edd
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 0x7eeb
movl 0x3c(%rbx), %ecx
addl (%rax), %ecx
movl %ecx, 0x28(%rbx)
btl $0xd, %ebp
jae 0x7f02
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 0x7f37
movl 0x3c(%rbx), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x2c(%rbx)
jmp 0x7f37
btl $0xb, %ebp
jae 0x7f1c
addl %edx, 0x28(%rbx)
btl $0xa, %ebp
jae 0x7f25
subl %edx, 0x28(%rbx)
btl $0x9, %ebp
jae 0x7f2e
addl %ecx, 0x2c(%rbx)
btl $0x8, %ebp
jae 0x7f37
subl %ecx, 0x2c(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7f40
// File: /workspace/github_c_makefile_star2_O2/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 0x7f5f
cmpl $0x0, 0x48(%rbx)
je 0x7f5f
andl $0x0, 0x28(%rbx)
movl 0x2c(%rbx), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl %eax, %edx
jne 0x7f77
cmpl $0x0, 0x4c(%rbx)
je 0x7f77
andl $0x0, 0x2c(%rbx)
movl 0x30(%rbx), %eax
movl 0x6c(%rbx), %ecx
cmpl %ecx, %eax
jge 0x7f86
movl %ecx, 0x30(%rbx)
movl %ecx, %eax
movl 0x74(%rbx), %ecx
testl %ecx, %ecx
sete %dl
cmpl %ecx, %eax
setle %al
orb %dl, %al
jne 0x7f9a
movl %ecx, 0x30(%rbx)
movl 0x34(%rbx), %eax
movl 0x70(%rbx), %ecx
cmpl %ecx, %eax
jge 0x7fa9
movl %ecx, 0x34(%rbx)
movl %ecx, %eax
movl 0x78(%rbx), %ecx
testl %ecx, %ecx
sete %dl
cmpl %ecx, %eax
setle %al
orb %dl, %al
jne 0x7fbd
movl %ecx, 0x34(%rbx)
movq %rbx, %rdi
callq 0x5e5f
movq %rbx, %rdi
popq %rbx
jmp 0x9438
// File: /workspace/github_c_makefile_star2_O2/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 0x8086
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
callq 0x66c6
leaq 0x7734(%rip), %r12      # 0xf728
movq (%r12), %rdi
movq 0x28(%rbx), %rsi
pushq $0x1
popq %rcx
xorl %edx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x45e0
testl %eax, %eax
jne 0x805c
pushq $0x3
popq %r14
leaq 0x8(%rsp), %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4510
movl 0x5c(%rsp), %eax
cmpl $0x2, 0x8(%rsp)
movl 0x54(%rbx), %ecx
jne 0x804d
cmpl %ecx, %eax
jne 0x8019
callq 0x66c6
cmpl $0x2, 0x8(%rsp)
je 0x8019
movl 0x5c(%rsp), %eax
movl 0x54(%rbx), %ecx
cmpl %ecx, %eax
je 0x8019
movq (%r12), %rdi
xorl %esi, %esi
callq 0x4450
leaq 0x76a5(%rip), %rbx      # 0xf708
movq (%rbx), %rdi
leaq 0x76b3(%rip), %rax      # 0xf720
movq (%rax), %rsi
callq 0x8282
movq %rax, (%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x80d6
movl 0x7c(%rdi), %ecx
movl 0x80(%rdi), %r8d
cmpl $0x2, %ecx
pushq $0x10
popq %rax
cmovll %eax, %ecx
cmpl $0x2, %r8d
cmovgel %r8d, %eax
cmpl $0x4, (%rsi)
jne 0x80d7
movl 0x54(%rsi), %esi
jmp 0x5b0c
retq
btl $0xe, %edx
jb 0x80e8
btl $0x12, %edx
jb 0x8115
jmp 0x7f40
btl $0xb, %edx
jae 0x80f1
addl %ecx, 0x30(%rdi)
btl $0xa, %edx
jae 0x80fa
subl %ecx, 0x30(%rdi)
btl $0x9, %edx
jae 0x8103
addl %eax, 0x34(%rdi)
btl $0x8, %edx
jae 0x7f40
subl %eax, 0x34(%rdi)
jmp 0x7f40
notl %edx
xorl %ecx, %ecx
testw $0xc00, %dx             # imm = 0xC00
sete %cl
leal 0x2(%rcx), %eax
testw $0x3000, %dx            # imm = 0x3000
cmovnel %ecx, %eax
pushq $0x2
popq %rsi
movl %eax, %edx
jmp 0x64d6
// File: /workspace/github_c_makefile_star2_O2/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 0x816b
testw %bp, %bp
jns 0x8171
btl $0x12, %ebp
jb 0x8183
btl $0xe, %ebp
jb 0x81a9
movzbl %bpl, %esi
jmp 0x8186
btl $0x12, %ebp
jb 0x8178
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $-0x1, 0x20(%rbx)
je 0x8194
pushq $-0x1
popq %rsi
jmp 0x819b
movl 0x64(%rbx), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8e46
movq 0x10(%rbx), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5573
btl $0x9, %ebp
jae 0x81c0
movl 0x60(%rbx), %esi
testl %esi, %esi
je 0x81c0
decl %esi
movq %rbx, %rdi
callq 0x8e46
btl $0x8, %ebp
jae 0x8171
movl 0x60(%rbx), %esi
leaq 0x7720(%rip), %rax      # 0xf8f0
movl 0x2c(%rax), %eax
decl %eax
cmpl %eax, %esi
jae 0x8171
incl %esi
jmp 0x8186
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x41e0
testq %rax, %rax
je 0x822f
andq $0x0, (%rax)
movq %r15, 0x8(%rax)
testq %rbx, %rbx
je 0x822c
movq %r14, (%rax)
cmpq %rbx, %r14
je 0x822c
movq %rbx, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
cmpq %r14, %rdx
je 0x8227
testq %rdx, %rdx
jne 0x8213
andq $0x0, (%rax)
movq %rax, (%rcx)
jmp 0x822f
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8280
movq %rsp, %rdi
movq %rax, %rdx
testq %rdx, %rdx
je 0x8280
movq %rdi, %rcx
movq %rdx, %rdi
movq (%rdx), %rdx
cmpq %rsi, 0x8(%rdi)
jne 0x8260
movq %rdx, (%rcx)
callq 0x42d0
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax, %rax
je 0x82d1
cmpq %rsi, 0x8(%rax)
je 0x82d1
movq (%rax), %rax
jmp 0x82c1
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9a48
testq %rax, %rax
je 0x86ec
movq 0x7273(%rip), %rdi      # 0xf950
movq %rax, %rsi
callq 0x8238
movq %rax, 0x7264(%rip)      # 0xf950
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x99bc
movq %rax, %rbx
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
movq %rax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0x4480
testq %rax, %rax
je 0x8734
movq %rax, %r15
incq %r15
movb $0x0, (%rax)
jmp 0x8737
xorl %r15d, %r15d
cmpb $0x0, (%r14)
je 0x8748
movq %r14, %rdi
callq 0x9a48
movq %rax, (%rbx)
testq %r15, %r15
je 0x875f
cmpb $0x0, (%r15)
je 0x875f
movq %r15, %rdi
callq 0x9a48
movq %rax, 0x8(%rbx)
movq 0x717a(%rip), %rdi      # 0xf8e0
movq %rbx, %rsi
callq 0x8238
movq %rax, 0x716b(%rip)      # 0xf8e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x715e(%rip), %rax      # 0xf8e0
testq %rax, %rax
je 0x87a5
pushq %rbx
movq 0x8(%rax), %rbx
leaq 0x14(%rbx), %rsi
leaq 0x18(%rbx), %rdx
leaq 0x1c(%rbx), %rcx
leaq 0x20(%rbx), %r8
callq 0x4790
movl %eax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4720
movq 0x7111(%rip), %rcx      # 0xf8e0
testq %rcx, %rcx
je 0x87e8
cmpl $-0x1, %eax
je 0x87e1
cmpl %eax, 0x713d(%rip)      # 0xf91c
jbe 0x87e8
movq 0x8(%rcx), %rcx
movl %eax, 0x28(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: screen_probe_monitors
void screen_probe_monitors(struct screen *s) {
#if defined(RANDR) && (RANDR_MAJOR == 1) && (RANDR_MINOR >= 5)
        if (display.have_randr && !option.wholescreen) {
		int nmonitors;
		XRRMonitorInfo *monitors;
		// Populate list of active monitors
		LOG_XENTER("XRRGetMonitors(screen=%d)", s->screen);
		monitors = XRRGetMonitors(display.dpy, s->root, True, &nmonitors);
		if (monitors) {
			struct monitor *new_monitors = s->monitors;
			if (nmonitors != s->nmonitors) {
				// allocating in multiple of 4 should stop us
				// having to reallocate at all in the most
				// common uses
				int n = (nmonitors | 3) + 1;
				new_monitors = realloc(s->monitors, n * sizeof(struct monitor));
			}
			if (new_monitors) {
				s->monitors = new_monitors;
				for (int i = 0; i < nmonitors; i++) {
					LOG_XDEBUG("monitor %d: %dx%d+%d+%d\n", i, monitors[i].width, monitors[i].height, monitors[i].x, monitors[i].y);
					s->monitors[i].x = monitors[i].x;
					s->monitors[i].y = monitors[i].y;
					s->monitors[i].width = monitors[i].width;
					s->monitors[i].height = monitors[i].height;
					s->monitors[i].area = monitors[i].width * monitors[i].height;
				}
				s->nmonitors = nmonitors;
			}
			LOG_XLEAVE();
			XRRFreeMonitors(monitors);
			return;
		}
		LOG_XLEAVE();
	}
#endif

	s->nmonitors = 1;
	if (!s->monitors) {
		s->monitors = xmalloc(sizeof(struct monitor));
	}
	s->monitors[0].x = 0;
	s->monitors[0].y = 0;
	s->monitors[0].width = DisplayWidth(display.dpy, s->screen);
	s->monitors[0].height = DisplayHeight(display.dpy, s->screen);
	s->monitors[0].area = s->monitors[0].width * s->monitors[0].height;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6aa8(%rip), %r15      # 0xf728
cmpl $0x0, 0x180(%r15)
je 0x8d1a
leaq 0x6c5b(%rip), %rax      # 0xf8f0
cmpl $0x0, 0x34(%rax)
jne 0x8d1a
movq (%r15), %rdi
movq 0x10(%rbx), %rsi
pushq $0x1
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0x4190
testq %rax, %rax
je 0x8d1a
movq %rax, %r14
movq 0x70(%rbx), %rax
movslq 0xc(%rsp), %rcx
cmpl 0x6c(%rbx), %ecx
je 0x8cd9
orq $0x3, %rcx
imulq $0x14, %rcx, %rsi
addq $0x14, %rsi
movq %rax, %rdi
callq 0x46c0
testq %rax, %rax
je 0x8d64
movq %rax, 0x70(%rbx)
movq %r14, %rcx
addq $0x14, %rcx
addq $0x10, %rax
xorl %edx, %edx
movslq 0xc(%rsp), %rsi
cmpq %rsi, %rdx
jge 0x8d61
movups (%rcx), %xmm0
movl 0xc(%rcx), %esi
imull 0x8(%rcx), %esi
movups %xmm0, -0x10(%rax)
movl %esi, (%rax)
incq %rdx
addq $0x38, %rcx
addq $0x14, %rax
jmp 0x8cf3
movl $0x1, 0x6c(%rbx)
movq 0x70(%rbx), %rax
testq %rax, %rax
jne 0x8d36
pushq $0x14
popq %rdi
callq 0x99bc
movq %rax, 0x70(%rbx)
andq $0x0, (%rax)
movq (%r15), %rcx
movq 0xe8(%rcx), %rcx
movslq (%rbx), %rdx
shlq $0x7, %rdx
movl 0x18(%rcx,%rdx), %esi
movl %esi, 0x8(%rax)
movl 0x1c(%rcx,%rdx), %ecx
movl %ecx, 0xc(%rax)
imull %esi, %ecx
movl %ecx, 0x10(%rax)
jmp 0x8d6c
movl %esi, 0x6c(%rbx)
movq %r14, %rdi
callq 0x4300
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: screen_deinit
void screen_deinit(struct screen *s) {
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_SUPPORTED));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST_STACKING));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_NUMBER_OF_DESKTOPS));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_GEOMETRY));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_VIEWPORT));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CURRENT_DESKTOP));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_ACTIVE_WINDOW));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_WORKAREA));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_SUPPORTING_WM_CHECK));
	XDestroyWindow(display.dpy, s->supporting);
	free(s->monitors);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x69a4(%rip), %r14      # 0xf728
movq 0x10(%rdi), %rsi
movq (%r14), %rdi
movq 0x40(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x48(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x50(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x58(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x60(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x68(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x70(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x78(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x80(%r14), %rdx
callq 0x42e0
movq 0x10(%rbx), %rsi
movq (%r14), %rdi
movq 0x88(%r14), %rdx
callq 0x42e0
movq (%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x4320
movq 0x70(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: switch_vdesk
void switch_vdesk(struct screen *s, unsigned v) {
#ifdef DEBUG
	int nhidden = 0, nraised = 0;
#endif

	// Sanity check vdesk number.
	if (!valid_vdesk(v))
		return;

	// Selected == current?  Do nothing.
	if (v == s->vdesk)
		return;

	LOG_ENTER("switch_vdesk(screen=%d, from=%d, to=%d)", s->screen, s->vdesk, v);

	// If current client is not fixed, deselect it.  An enter event from
	// mapping clients may select a new one.
	if (current && !is_fixed(current)) {
		select_client(NULL);
	}

	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->vdesk == s->vdesk) {
			client_hide(c);
#ifdef DEBUG
			nhidden++;
#endif
		} else if (c->vdesk == v) {
			if (!c->is_dock || s->docks_visible)
				client_show(c);
#ifdef DEBUG
			nraised++;
#endif
		}
	}

	// Store previous vdesk, so that user may toggle back to it
	s->old_vdesk = s->vdesk;

	// Update current vdesk (including EWMH properties)
	s->vdesk = v;
	ewmh_set_net_current_desktop(s);

	LOG_DEBUG("%d hidden, %d raised\n", nhidden, nraised);
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x8e60
leaq 0x6a95(%rip), %rax      # 0xf8f0
cmpl %ebp, 0x2c(%rax)
jbe 0x8e65
cmpl %ebp, 0x60(%rbx)
jne 0x8e6a
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x68af(%rip), %rax      # 0xf720
movq (%rax), %rax
testq %rax, %rax
je 0x8e86
cmpl $-0x1, 0x20(%rax)
je 0x8e86
xorl %edi, %edi
callq 0x54cf
leaq 0x687b(%rip), %r14      # 0xf708
movq (%r14), %r14
testq %r14, %r14
je 0x8ec8
movq 0x8(%r14), %rdi
cmpq %rbx, 0x10(%rdi)
jne 0x8e8d
movl 0x20(%rdi), %eax
cmpl 0x60(%rbx), %eax
jne 0x8eae
callq 0x52dc
jmp 0x8e8d
cmpl %ebp, %eax
jne 0x8e8d
cmpl $0x0, 0x94(%rdi)
je 0x8ec1
cmpl $0x0, 0x68(%rbx)
je 0x8e8d
callq 0x533d
jmp 0x8e8d
movl 0x60(%rbx), %eax
movl %eax, 0x64(%rbx)
movl %ebp, 0x60(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7a8a
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: set_docks_visible
void set_docks_visible(struct screen *s, int is_visible) {
	LOG_ENTER("set_docks_visible(screen=%d, is_visible=%d)", s->screen, is_visible);

	s->docks_visible = is_visible;

	// Traverse client list and hide or show any docks on this screen as
	// appropriate.

	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->is_dock) {
			if (is_visible) {
				// XXX I've assumed that if you want to see
				// them, you also want them raised...
				if (is_fixed(c) || (c->vdesk == s->vdesk)) {
					client_show(c);
					client_raise(c);
				}
			} else {
				client_hide(c);
			}
		}
	}

	LOG_LEAVE();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x68(%rdi)
leaq 0x6814(%rip), %r12      # 0xf708
movq (%r12), %r12
testq %r12, %r12
je 0x8f41
movq 0x8(%r12), %r15
cmpq %r14, 0x10(%r15)
jne 0x8ef4
cmpl $0x0, 0x94(%r15)
je 0x8ef4
testl %ebx, %ebx
je 0x8f37
movl 0x20(%r15), %eax
cmpl $-0x1, %eax
je 0x8f25
cmpl 0x60(%r14), %eax
jne 0x8ef4
movq %r15, %rdi
callq 0x533d
movq %r15, %rdi
callq 0x5360
jmp 0x8ef4
movq %r15, %rdi
callq 0x52dc
jmp 0x8ef4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: scan_clients_before_resize
void scan_clients_before_resize(struct screen *s) {
	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		// only handle clients on the screen being resized
		if (c->screen != s)
			continue;

		struct monitor *m = client_monitor(c, NULL);

		int mw = m->width;
		int mh = m->height;
		int cx = c->oldw ? c->oldx : c->x;
		int cy = c->oldh ? c->oldy : c->y;

		c->mon_offx = (double)(cx - m->x) / (double)mw;
		c->mon_offy = (double)(cy - m->y) / (double)mh;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x67ac(%rip), %r15      # 0xf708
movq (%r15), %r15
testq %r15, %r15
je 0x8fc3
movq 0x8(%r15), %r14
cmpq %rbx, 0x10(%r14)
jne 0x8f5c
movq %r14, %rdi
xorl %esi, %esi
callq 0x511e
leaq 0x40(%r14), %rcx
leaq 0x28(%r14), %rdx
cmpl $0x0, 0x48(%r14)
cmoveq %rdx, %rcx
leaq 0x44(%r14), %rdx
leaq 0x2c(%r14), %rsi
cmpl $0x0, 0x4c(%r14)
cmoveq %rsi, %rdx
movq (%rax), %xmm0
movd (%rdx), %xmm1
movd (%rcx), %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
psubd %xmm0, %xmm2
cvtdq2pd 0x8(%rax), %xmm0
cvtdq2pd %xmm2, %xmm1
divpd %xmm0, %xmm1
movupd %xmm1, 0x58(%r14)
jmp 0x8f5c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: fix_screen_after_resize
void fix_screen_after_resize(struct screen *s) {
	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		// only handle clients on the screen being resized
		if (c->screen != s)
			continue;
		Bool intersects;
		struct monitor *m = client_monitor(c, &intersects);

		if (c->oldw) {
			// horiz maximised: update width, update old x pos
			c->x = m->x - c->border;
			c->width = m->width;
			c->oldx = m->x + c->mon_offx * m->width;
		} else {
			// horiz normal: update x pos
			if (!intersects)
				c->x = m->x + c->mon_offx * m->width;
		}

		if (c->oldh) {
			// vert maximised: update height, update old y pos
			c->y = m->y - c->border;
			c->height = m->height;
			c->oldy = m->y + c->mon_offy * m->height;
		} else {
			// vert normal: update y pos
			if (!intersects)
				c->y = m->y + c->mon_offy * m->height;
		}
		client_moveresize(c);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x672a(%rip), %r12      # 0xf708
leaq 0x4(%rsp), %r14
pushq $0x44
popq %r13
pushq $0x40
popq %rbp
movq (%r12), %r12
testq %r12, %r12
je 0x90c8
movq 0x8(%r12), %r15
cmpq %rbx, 0x10(%r15)
jne 0x8fea
movq %r15, %rdi
movq %r14, %rsi
callq 0x511e
cmpl $0x0, 0x48(%r15)
je 0x9044
movl (%rax), %ecx
cvtsi2sd %ecx, %xmm1
subl 0x3c(%r15), %ecx
movl %ecx, 0x28(%r15)
movl 0x8(%rax), %ecx
movl %ecx, 0x30(%r15)
cvtsi2sd %ecx, %xmm0
mulsd 0x58(%r15), %xmm0
addsd %xmm1, %xmm0
movq %rbp, %rcx
cvttsd2si %xmm0, %edx
movl %edx, (%r15,%rcx)
jmp 0x904b
cmpl $0x0, 0x4(%rsp)
je 0x9097
cmpl $0x0, 0x4c(%r15)
je 0x9083
movl 0x4(%rax), %ecx
cvtsi2sd %ecx, %xmm1
subl 0x3c(%r15), %ecx
movl %ecx, 0x2c(%r15)
movl 0xc(%rax), %eax
movl %eax, 0x34(%r15)
cvtsi2sd %eax, %xmm0
mulsd 0x60(%r15), %xmm0
addsd %xmm1, %xmm0
movq %r13, %rax
cvttsd2si %xmm0, %ecx
movl %ecx, (%r15,%rax)
jmp 0x908a
cmpl $0x0, 0x4(%rsp)
je 0x90af
movq %r15, %rdi
callq 0x6481
jmp 0x8fea
cvtsi2sdl (%rax), %xmm1
cvtsi2sdl 0x8(%rax), %xmm0
mulsd 0x58(%r15), %xmm0
addsd %xmm1, %xmm0
pushq $0x28
popq %rcx
jmp 0x903a
cvtsi2sdl 0x4(%rax), %xmm1
cvtsi2sdl 0xc(%rax), %xmm0
mulsd 0x60(%r15), %xmm0
addsd %xmm1, %xmm0
pushq $0x2c
popq %rax
jmp 0x9079
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/screen.c
// Function: find_screen
struct screen *find_screen(Window root) {
	for (int i = 0; i < display.nscreens; i++) {
		if (display.screens[i].root == root)
			return &display.screens[i];
	}
	return NULL;
}

// Assembly:
leaq 0x664a(%rip), %rax      # 0xf728
movslq 0x188(%rax), %rcx
movq 0x190(%rax), %rdx
addq $-0x78, %rdx
pushq $-0x1
popq %rsi
incq %rsi
cmpq %rcx, %rsi
jge 0x910c
leaq 0x78(%rdx), %rax
cmpq %rdi, 0x88(%rdx)
movq %rax, %rdx
jne 0x90f3
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: spawn
void spawn(const char *const cmd[]) {
	struct screen *current_screen = find_current_screen();
	pid_t pid;

	if (current_screen && current_screen->display)
		putenv(current_screen->display);
	if (!(pid = fork())) {
		// Put first fork in a new session
		setsid();
		switch (fork()) {
			// execvp()'s prototype is (char *const *) suggesting that it
			// modifies the contents of the strings.  The prototype is this
			// way due to SUS maintaining compatability with older code.
			// However, execvp guarantees not to modify argv, so the following
			// cast is valid.
			case 0: execvp(cmd[0], (char *const *)cmd); break;
			default: _exit(0);
		}
	}
	if (pid > 0)
		wait(NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x910f
testq %rax, %rax
je 0x9180
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x9180
callq 0x4470
callq 0x4680
testl %eax, %eax
je 0x9193
jle 0x91ad
xorl %edi, %edi
popq %rbx
jmp 0x40d0
callq 0x40b0
callq 0x4680
testl %eax, %eax
jne 0x91af
movq (%rbx), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x4150
popq %rbx
retq
xorl %edi, %edi
callq 0x4230
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: get_pointer_root_xy
Bool get_pointer_root_xy(Window w, int *x, int *y) {
	Window root_r, child_r;
	int root_x_r, root_y_r;
	int win_x_r, win_y_r;
	unsigned mask_r;
	if (!x)
		x = &root_x_r;
	if (!y)
		y = &root_y_r;
	return XQueryPointer(display.dpy, w, &root_r, &child_r, x, y, &win_x_r, &win_y_r, &mask_r);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rax
testq %rsi, %rsi
leaq 0x1c(%rsp), %r8
cmovneq %rsi, %r8
testq %rdx, %rdx
leaq 0x18(%rsp), %r9
cmovneq %rdx, %r9
leaq 0x64c0(%rip), %rcx      # 0xf728
movq (%rcx), %rdi
subq $0x8, %rsp
leaq 0x14(%rsp), %r10
leaq 0x18(%rsp), %r11
leaq 0x1c(%rsp), %rbx
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rax, %rsi
pushq %r10
pushq %r11
pushq %rbx
callq 0x4600
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: get_property
void *get_property(Window w, Atom property, Atom req_type,
		   unsigned long *nitems_return) {
	Atom actual_type;
	int actual_format;
	unsigned long bytes_after;
	unsigned char *prop;
	if (XGetWindowProperty(display.dpy, w, property,
			       0L, MAXIMUM_PROPERTY_LENGTH / 4, False,
			       req_type, &actual_type, &actual_format,
			       nitems_return, &bytes_after, &prop) == Success) {
		if (actual_type == req_type)
			return (void *)prop;
		XFree(prop);
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x646f(%rip), %rcx      # 0xf728
movq (%rcx), %rdi
leaq 0x8(%rsp), %r10
leaq 0x20(%rsp), %r11
leaq 0x1c(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %r14d, %r14d
movl $0x400, %r8d            # imm = 0x400
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %r10
pushq %r11
pushq %rax
pushq %r15
pushq %r12
pushq %rbx
callq 0x41c0
addq $0x30, %rsp
testl %eax, %eax
jne 0x930c
movq 0x8(%rsp), %r14
cmpq %rbx, 0x10(%rsp)
je 0x930c
movq %r14, %rdi
callq 0x4050
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: window_normal_border
int window_normal_border(Window w) {
	int bw = option.bw;
	PropMwmHints *mprop;
	unsigned long nitems;
	if ( (mprop = get_property(w, X_ATOM(_MOTIF_WM_HINTS), X_ATOM(_MOTIF_WM_HINTS), &nitems)) ) {
		if (nitems >= PROP_MWM_HINTS_ELEMENTS
		    && (mprop->flags & MWM_HINTS_DECORATIONS)
		    && !(mprop->decorations & MWM_DECOR_ALL)
		    && !(mprop->decorations & MWM_DECOR_BORDER)) {
			bw = 0;
		}
		XFree(mprop);
	}
	return bw;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x65c9(%rip), %rax      # 0xf8f0
movl 0x28(%rax), %ebx
leaq 0x63f7(%rip), %rax      # 0xf728
movq 0x28(%rax), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, %rsi
callq 0x929b
testq %rax, %rax
je 0x9365
cmpq $0x3, 0x8(%rsp)
jb 0x935d
testb $0x2, (%rax)
je 0x935d
xorl %ecx, %ecx
testb $0x3, 0x10(%rax)
cmovel %ecx, %ebx
movq %rax, %rdi
callq 0x4050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: interruptibleXNextEvent
int interruptibleXNextEvent(XEvent *event) {
	fd_set fds;
	int rc;
	int dpy_fd = ConnectionNumber(display.dpy);
	for (;;) {
		if (XPending(display.dpy)) {
			XNextEvent(display.dpy, event);
			return 1;
		}
		FD_ZERO(&fds);
		FD_SET(dpy_fd, &fds);
		rc = select(dpy_fd + 1, &fds, NULL, NULL, NULL);
		if (rc < 0) {
			if (errno == EINTR) {
				return 0;
			} else {
				LOG_ERROR("interruptibleXNextEvent(): select()\n");
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, (%rsp)
leaq 0x639f(%rip), %rbx      # 0xf728
movq (%rbx), %rdi
movl 0x10(%rdi), %ebp
pushq $0x40
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movslq %eax, %r12
shll $0x6, %eax
movl %ebp, %ecx
subl %eax, %ecx
pushq $0x1
popq %r13
movq %r13, %r14
shlq %cl, %r14
incl %ebp
leaq 0x8(%rsp), %r15
callq 0x4760
testl %eax, %eax
jne 0x9417
xorl %eax, %eax
cmpq $0x10, %rax
je 0x93ce
andq $0x0, 0x8(%rsp,%rax,8)
incq %rax
jmp 0x93bd
orq %r14, 0x8(%rsp,%r12,8)
movl %ebp, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4140
testl %eax, %eax
jns 0x940e
callq 0x44d0
cmpl $0x4, (%rax)
je 0x9413
movq 0x5bf7(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x1f46(%rip), %rdi      # 0xb349
pushq $0x24
popq %rsi
movq %r13, %rdx
callq 0x46b0
movq (%rbx), %rdi
jmp 0x93b2
xorl %eax, %eax
jmp 0x9426
movq (%rbx), %rdi
movq (%rsp), %rsi
callq 0x43d0
pushq $0x1
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/util.c
// Function: discard_enter_events
void discard_enter_events(struct client *except) {
	XEvent tmp, putback_ev;
	int putback = 0;
	XSync(display.dpy, False);
	while (XCheckMaskEvent(display.dpy, EnterWindowMask, &tmp)) {
		if (tmp.xcrossing.window == except->parent) {
			memcpy(&putback_ev, &tmp, sizeof(XEvent));
			putback = 1;
		}
	}
	if (putback) {
		XPutBackEvent(display.dpy, &putback_ev);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x62d5(%rip), %r13      # 0xf728
movq (%r13), %rdi
xorl %esi, %esi
callq 0x4500
movb $0x1, %bpl
pushq $0x10
popq %r14
leaq 0xc8(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4430
testl %eax, %eax
je 0x94a7
movq 0xe8(%rsp), %rax
cmpq 0x8(%rbx), %rax
jne 0x9472
movl $0xc0, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4740
xorl %ebp, %ebp
jmp 0x9472
testb $0x1, %bpl
jne 0x94bb
movq (%r13), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4460
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/xconfig.c
// Function: xconfig_parse_line
void xconfig_parse_line(struct xconfig_option *options, const char *line) {
	// skip leading spaces
	while (isspace((int)*line))
		line++;

	// end of line or comment?
	if (*line == 0 || *line == '#')
		return;

	// from here on, work on a copy of the string
	char *linedup = xstrdup(line);

	// whitespace separates option from arguments
	char *optstr = strtok(linedup, "\t\n\v\f\r ");
	if (optstr == NULL) {
		goto done;
	}

	struct xconfig_option *opt = find_option(options, optstr);
	if (opt == NULL) {
		LOG_INFO("Ignoring unknown option `%s'\n", optstr);
		goto done;
	}

	char *arg;
	if (opt->type == XCONFIG_STR_LIST) {
		// special case: spaces here mean something
		arg = strtok(NULL, "\n\v\f\r");
		while (isspace(*arg)) {
			arg++;
		}
	} else {
		arg = strtok(NULL, "\t\n\v\f\r ");
	}

	set_option(opt, arg ? arg : "");
done:
	free(linedup);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4340
movq %rax, %r14
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x94ec
movzbl %cl, %eax
testl %eax, %eax
je 0x9507
cmpl $0x23, %eax
jne 0x9513
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x9a48
movq %rax, %rbx
leaq 0x1e67(%rip), %rsi      # 0xb38c
movq %rax, %rdi
callq 0x4580
testq %rax, %rax
je 0x95a9
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x95bc
testq %rax, %rax
je 0x9572
movq %rax, %r15
cmpl $0x4, (%rax)
jne 0x9585
leaq 0x1e5d(%rip), %rsi      # 0xb3b1
xorl %edi, %edi
callq 0x4580
movq (%r14), %rcx
decq %rax
movsbq 0x1(%rax), %rdx
incq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x9561
jmp 0x9593
leaq 0x1e1a(%rip), %rdi      # 0xb393
movq %r12, %rsi
xorl %eax, %eax
callq 0x4060
jmp 0x95a9
leaq 0x1e00(%rip), %rsi      # 0xb38c
xorl %edi, %edi
callq 0x4580
testq %rax, %rax
leaq 0x1476(%rip), %rsi      # 0xaa13
cmovneq %rax, %rsi
movq %r15, %rdi
callq 0x95f3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/xconfig.c
// Function: xconfig_parse_file
enum xconfig_result xconfig_parse_file(struct xconfig_option *options,
		const char *filename) {
	char buf[256];
	char *line;
	FILE *cfg;
	cfg = fopen(filename, "r");
	if (cfg == NULL) return XCONFIG_FILE_ERROR;

	while ((line = fgets(buf, sizeof(buf), cfg))) {
		xconfig_parse_line(options, line);
	}
	fclose(cfg);
	return XCONFIG_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xa33(%rip), %rsi       # 0xa26b
movq %rax, %rdi
callq 0x41f0
testq %rax, %rax
je 0x9879
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x42a0
testq %rax, %rax
je 0x986d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x94d0
jmp 0x984b
movq %r14, %rdi
callq 0x45f0
xorl %eax, %eax
jmp 0x987c
pushq $0x3
popq %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mati75[P]evilwm/xconfig.c
// Function: xconfig_parse_cli
enum xconfig_result xconfig_parse_cli(struct xconfig_option *options,
		int argc, char **argv, int *argn) {
	int _argn;
	const char *optstr;
	_argn = argn ? *argn : 1;

	while (_argn < argc) {
		// No leading '-' means end of options
		if (argv[_argn][0] != '-') {
			break;
		}

		// "--" ends options, per tradition
		if (0 == strcmp("--", argv[_argn])) {
			_argn++;
			break;
		}

		optstr = argv[_argn]+1;
		// Allow double '-' to introduce option
		if (*optstr == '-')
			optstr++;

		struct xconfig_option *opt = find_option(options, optstr);
		if (opt == NULL) {
			if (argn) *argn = _argn;
			return XCONFIG_BAD_OPTION;
		}

		// Option types with no argument
		if (opt->type == XCONFIG_BOOL || opt->type == XCONFIG_CALL_0) {
			set_option(opt, NULL);
			_argn++;
			continue;
		}

		// Option types with one argument
		if ((_argn + 1) >= argc) {
			if (argn)
				*argn = _argn;
			return XCONFIG_MISSING_ARG;
		}
		set_option(opt, argv[_argn+1]);
		_argn += 2;
	}

	if (argn) {
		*argn = _argn;
	}
	return XCONFIG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
pushq $0x1
popq %rbx
movl %ebx, %r12d
testq %rcx, %rcx
je 0x98aa
movl (%rcx), %r12d
movq %rcx, (%rsp)
cmpl %ebp, %r12d
jge 0x992c
movslq %r12d, %rax
movq (%r14,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x992c
movzbl 0x1(%rsi), %eax
subl $0x2d, %eax
jne 0x98cc
movzbl 0x2(%rsi), %eax
negl %eax
testl %eax, %eax
je 0x9929
cmpb $0x2d, 0x1(%rsi)
je 0x98dd
incq %rsi
jmp 0x98e1
addq $0x2, %rsi
movq %r15, %rdi
callq 0x95bc
testq %rax, %rax
je 0x9930
movl (%rax), %ecx
testl %ecx, %ecx
je 0x9917
movl $0x0, %esi
movl %ebx, %r13d
cmpl $0x5, %ecx
je 0x991c
leal 0x1(%r12), %ecx
cmpl %ebp, %ecx
jge 0x9934
movslq %ecx, %rcx
movq (%r14,%rcx,8), %rsi
pushq $0x2
popq %r13
jmp 0x991c
xorl %esi, %esi
movl %ebx, %r13d
movq %rax, %rdi
callq 0x95f3
addl %r13d, %r12d
jmp 0x98ae
incl %r12d
xorl %eax, %eax
jmp 0x9937
pushq $0x1
jmp 0x9936
pushq $0x2
popq %rax
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x9943
movl %r12d, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq