LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x7896(%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
movl $0x7, %r10d
testl %ecx, %ecx
je 0x7ef4
cmpl 0x6c(%rbx), %ecx
jne 0x7ef4
movl 0x78(%rbx), %ecx
testl %ecx, %ecx
je 0x7ef4
xorl %r10d, %r10d
cmpl 0x70(%rbx), %ecx
sete %r10b
xorl $0x7, %r10d
movq (%rbx), %rsi
movq (%rax), %rdi
movq 0x110(%rax), %rdx
movq %rsp, %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x4640
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x7f2c
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/ewmh.c
// Function: ewmh_set_net_wm_state
void ewmh_set_net_wm_state(struct client *c) {
	Atom state[4];
	int i = 0;
	if (c->oldh)
		state[i++] = X_ATOM(_NET_WM_STATE_MAXIMIZED_VERT);
	if (c->oldw)
		state[i++] = X_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ);
	if (c->oldh && c->oldw)
		state[i++] = X_ATOM(_NET_WM_STATE_FULLSCREEN);
	if (c == current || c->is_dock)
		state[i++] = X_ATOM(_NET_WM_STATE_FOCUSED);
	if (c == current) {
		if (c->screen->active != c->window) {
			XChangeProperty(display.dpy, c->screen->root,
			                X_ATOM(_NET_ACTIVE_WINDOW),
			                XA_WINDOW, 32, PropModeReplace,
			                (unsigned char *)&c->window, 1);
			c->screen->active = c->window;
		}
	} else if (c->screen->active == c->window) {
		Window w = None;
		XChangeProperty(display.dpy, c->screen->root, X_ATOM(_NET_ACTIVE_WINDOW),
		                XA_WINDOW, 32, PropModeReplace,
		                (unsigned char *)&w, 1);
		c->screen->active = None;
	}
	XChangeProperty(display.dpy, c->window, X_ATOM(_NET_WM_STATE),
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&state, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x4c(%rdi)
je 0x7f76
leaq 0x77e3(%rip), %rax      # 0xf728
movq 0xe8(%rax), %rcx
movq %rcx, (%rsp)
cmpl $0x0, 0x48(%rbx)
je 0x7f8e
movq 0xf0(%rax), %rcx
movq 0x100(%rax), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x3, %r14d
jmp 0x7f99
cmpl $0x0, 0x48(%rbx)
je 0x7f96
leaq 0x77a5(%rip), %rax      # 0xf728
movq 0xf0(%rax), %rax
movq %rax, (%rsp)
movl $0x1, %r14d
jmp 0x7f99
xorl %r14d, %r14d
leaq 0x7780(%rip), %rax      # 0xf720
cmpq %rbx, (%rax)
je 0x801c
cmpl $0x0, 0x94(%rbx)
je 0x7fc6
leaq 0x7773(%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 0x8071
xorl %r15d, %r15d
leaq 0x28(%rsp), %r10
movq %r15, (%r10)
leaq 0x773f(%rip), %rcx      # 0xf728
movq 0x10(%rax), %rsi
movq (%rcx), %rdi
movq 0x78(%rcx), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %r10
callq 0x4640
addq $0x10, %rsp
movq 0x10(%rbx), %rax
movq %r15, 0x20(%rax)
movq (%rbx), %rsi
jmp 0x8071
leaq 0x7705(%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 0x8071
movq 0x10(%rcx), %rsi
movq (%rax), %rdi
movq 0x78(%rax), %rdx
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rbx
callq 0x4640
addq $0x10, %rsp
movq (%rbx), %rsi
movq 0x10(%rbx), %rax
movq %rsi, 0x20(%rax)
leaq 0x76b0(%rip), %rax      # 0xf728
movq (%rax), %rdi
movq 0xe0(%rax), %rdx
movq %rsp, %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %rax
callq 0x4640
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75ea(%rip), %rbx      # 0xf728
movq 0xc0(%rbx), %rsi
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x975a
testq %rax, %rax
je 0x81b3
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x81b7
movq 0xc8(%rbx), %rdx
movq 0xd0(%rbx), %rsi
movq 0xd8(%rbx), %rdi
xorl %ebx, %ebx
xorl %r8d, %r8d
movq (%rax,%r8,8), %r9
xorl %r10d, %r10d
cmpq %rdx, %r9
sete %r10b
orl %ebx, %r10d
movl %r10d, %r11d
orl $0x2, %r11d
cmpq %rsi, %r9
cmovnel %r10d, %r11d
movl %r11d, %ebx
orl $0x4, %ebx
cmpq %rdi, %r9
cmovnel %r11d, %ebx
incq %r8
cmpq %r8, %rcx
jne 0x817d
jmp 0x81b9
xorl %ebx, %ebx
jmp 0x81c1
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x4050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x82b2
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5371
movl 0x7c(%rbx), %edx
movl 0x80(%rbx), %esi
cmpl $0x2, %edx
movl $0x10, %ecx
cmovll %ecx, %edx
cmpl $0x2, %esi
cmovgel %esi, %ecx
cmpl $0x4, (%r14)
jne 0x82b7
movl 0x54(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x616f
popq %rbx
popq %r14
popq %rbp
retq
btl $0xe, %ebp
jb 0x8309
btl $0xb, %ebp
jae 0x82d3
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 0x82e1
movl 0x3c(%rbx), %ecx
addl (%rax), %ecx
movl %ecx, 0x28(%rbx)
btl $0xd, %ebp
jae 0x82f8
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 0x832d
movl 0x3c(%rbx), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x2c(%rbx)
jmp 0x832d
btl $0xb, %ebp
jae 0x8312
addl %edx, 0x28(%rbx)
btl $0xa, %ebp
jae 0x831b
subl %edx, 0x28(%rbx)
btl $0x9, %ebp
jae 0x8324
addl %ecx, 0x2c(%rbx)
btl $0x8, %ebp
jae 0x832d
subl %ecx, 0x2c(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8336
// File: /workspace/github_c_makefile_star2_O3/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 0x8358
cmpl $0x0, 0x48(%rbx)
je 0x8358
movl $0x0, 0x28(%rbx)
movl 0x2c(%rbx), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl %eax, %edx
jne 0x8373
cmpl $0x0, 0x4c(%rbx)
je 0x8373
movl $0x0, 0x2c(%rbx)
movl 0x30(%rbx), %eax
movl 0x6c(%rbx), %ecx
cmpl %ecx, %eax
jge 0x8382
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 0x8396
movl %ecx, 0x30(%rbx)
movl 0x34(%rbx), %eax
movl 0x70(%rbx), %ecx
cmpl %ecx, %eax
jge 0x83a5
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 0x83b9
movl %ecx, 0x34(%rbx)
movq %rbx, %rdi
callq 0x615d
movq %rbx, %rdi
popq %rbx
jmp 0x9911
// File: /workspace/github_c_makefile_star2_O3/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 0x847a
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
callq 0x6a0d
leaq 0x733a(%rip), %r15      # 0xf728
movq (%r15), %rdi
movq 0x28(%rbx), %rsi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x45e0
testl %eax, %eax
jne 0x8452
movq %rsp, %r14
movq (%r15), %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x4510
movl 0x54(%rsp), %eax
cmpl $0x2, (%rsp)
movl 0x54(%rbx), %ecx
jne 0x8444
cmpl %ecx, %eax
jne 0x8411
callq 0x6a0d
cmpl $0x2, (%rsp)
je 0x8411
movl 0x54(%rsp), %eax
movl 0x54(%rbx), %ecx
cmpl %ecx, %eax
je 0x8411
movq (%r15), %rdi
xorl %esi, %esi
callq 0x4450
leaq 0x72af(%rip), %rbx      # 0xf708
movq (%rbx), %rdi
leaq 0x72bd(%rip), %rax      # 0xf720
movq (%rax), %rsi
callq 0x86c8
movq %rax, (%rbx)
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x84cc
movl 0x7c(%rdi), %ecx
movl 0x80(%rdi), %r8d
cmpl $0x2, %ecx
movl $0x10, %eax
cmovll %eax, %ecx
cmpl $0x2, %r8d
cmovgel %r8d, %eax
cmpl $0x4, (%rsi)
jne 0x84cd
movl 0x54(%rsi), %esi
jmp 0x5e0c
retq
btl $0xe, %edx
jb 0x84de
btl $0x12, %edx
jb 0x850b
jmp 0x8336
btl $0xb, %edx
jae 0x84e7
addl %ecx, 0x30(%rdi)
btl $0xa, %edx
jae 0x84f0
subl %ecx, 0x30(%rdi)
btl $0x9, %edx
jae 0x84f9
addl %eax, 0x34(%rdi)
btl $0x8, %edx
jae 0x8336
subl %eax, 0x34(%rdi)
jmp 0x8336
notl %edx
xorl %ecx, %ecx
testl $0xc00, %edx            # imm = 0xC00
sete %cl
leal 0x2(%rcx), %eax
testl $0x3000, %edx           # imm = 0x3000
cmovnel %ecx, %eax
movl $0x2, %esi
movl %eax, %edx
jmp 0x6800
// File: /workspace/github_c_makefile_star2_O3/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 0x8565
testw %bp, %bp
jns 0x856b
btl $0x12, %ebp
jb 0x8582
btl $0xe, %ebp
jb 0x85a8
movzbl %bpl, %esi
jmp 0x8585
btl $0x12, %ebp
jb 0x8572
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $-0x1, 0x20(%rbx)
je 0x8593
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jmp 0x859d
movl 0x64(%rbx), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x92d8
movq 0x10(%rbx), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5826
btl $0x9, %ebp
jae 0x85bf
movl 0x60(%rbx), %esi
testl %esi, %esi
je 0x85bf
decl %esi
movq %rbx, %rdi
callq 0x92d8
btl $0x8, %ebp
jae 0x856b
movl 0x60(%rbx), %esi
leaq 0x7321(%rip), %rax      # 0xf8f0
movl 0x2c(%rax), %eax
decl %eax
cmpl %eax, %esi
jae 0x856b
incl %esi
jmp 0x8585
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/list.c
// Function: list_insert_before
struct list *list_insert_before(struct list *list, struct list *before, void *data) {
	struct list *elem = list_new(data);
	if (!elem)
		return list;
	if (!list)
		return elem;
	elem->next = before;
	if (before == list)
		return elem;
	for (struct list *iter = list; iter; iter = iter->next) {
		if (iter->next == before) {
			iter->next = elem;
			return list;
		}
		if (!iter->next) {
			elem->next = NULL;
			iter->next = elem;
			return list;
		}
	}
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x41e0
testq %rax, %rax
je 0x8633
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
testq %rbx, %rbx
je 0x8630
movq %r14, (%rax)
cmpq %rbx, %r14
je 0x8630
movq %rbx, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
cmpq %r14, %rdx
je 0x862b
testq %rdx, %rdx
jne 0x8614
movq $0x0, (%rax)
movq %rax, (%rcx)
jmp 0x8633
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x86c6
testq %rax, %rax
je 0x86ad
cmpq %rsi, 0x8(%rax)
je 0x86b1
movq %rax, %rdi
movq %rdi, %rcx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x86c6
cmpq %rsi, 0x8(%rdi)
jne 0x869a
jmp 0x86b7
xorl %eax, %eax
jmp 0x86c6
movq %rsp, %rcx
movq %rax, %rdi
movq (%rdi), %rax
movq %rax, (%rcx)
callq 0x42d0
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/list.c
// Function: list_to_head
struct list *list_to_head(struct list *list, void *data) {
	if (!data)
		return list;
	list = list_delete(list, data);
	return list_prepend(list, data);
}

// Assembly:
movq %rdi, %rax
testq %rsi, %rsi
je 0x8710
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rax, %rdi
callq 0x867f
movq %rax, %r14
movl $0x10, %edi
callq 0x41e0
testq %rax, %rax
je 0x8706
movq $0x0, (%rax)
movq %rbx, 0x8(%rax)
testq %r14, %r14
je 0x8709
movq %r14, (%rax)
jmp 0x8709
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9f30
testq %rax, %rax
je 0x8b21
movq 0x6e3e(%rip), %rdi      # 0xf950
movq %rax, %rsi
callq 0x863c
movq %rax, 0x6e2f(%rip)      # 0xf950
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/main.c
// Function: set_app
static void set_app(const char *arg) {
	struct application *new = xmalloc(sizeof(struct application));
	char *tmp;
	new->res_name = new->res_class = NULL;
	new->geometry_mask = 0;
	new->is_dock = 0;
	new->vdesk = VDESK_NONE;
	if ((tmp = strchr(arg, '/'))) {
		*(tmp++) = 0;
	}
	if (*arg) {
		new->res_name = xstrdup(arg);
	}
	if (tmp && *tmp) {
		new->res_class = xstrdup(tmp);
	}
	applications = list_prepend(applications, new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x9eb8
movq %rax, %rbx
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
movq %rax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movq %r14, %rdi
movl $0x2f, %esi
callq 0x4480
testq %rax, %rax
je 0x8b70
movq %rax, %r15
incq %r15
movb $0x0, (%rax)
jmp 0x8b73
xorl %r15d, %r15d
cmpb $0x0, (%r14)
je 0x8b84
movq %r14, %rdi
callq 0x9f30
movq %rax, (%rbx)
testq %r15, %r15
je 0x8b9b
cmpb $0x0, (%r15)
je 0x8b9b
movq %r15, %rdi
callq 0x9f30
movq %rax, 0x8(%rbx)
movq 0x6d3e(%rip), %rdi      # 0xf8e0
movq %rbx, %rsi
callq 0x863c
movq %rax, 0x6d2f(%rip)      # 0xf8e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6d22(%rip), %rax      # 0xf8e0
testq %rax, %rax
je 0x8be1
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_O3/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 0x6cd5(%rip), %rcx      # 0xf8e0
testq %rcx, %rcx
je 0x8c24
cmpl $-0x1, %eax
je 0x8c1d
cmpl %eax, 0x6d01(%rip)      # 0xf91c
jbe 0x8c24
movq 0x8(%rcx), %rcx
movl %eax, 0x28(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6627(%rip), %r15      # 0xf728
cmpl $0x0, 0x180(%r15)
je 0x91b4
leaq 0x67da(%rip), %rax      # 0xf8f0
cmpl $0x0, 0x34(%rax)
jne 0x91b4
movq (%r15), %rdi
movq 0x10(%rbx), %rsi
leaq 0xc(%rsp), %rcx
movl $0x1, %edx
callq 0x4190
testq %rax, %rax
je 0x91b4
movq %rax, %r14
movq 0x70(%rbx), %rax
movslq 0xc(%rsp), %rcx
cmpl 0x6c(%rbx), %ecx
je 0x9164
orq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq 0x14(,%rcx,4), %rsi
movq %rax, %rdi
callq 0x46c0
testq %rax, %rax
je 0x91aa
movq %rax, 0x70(%rbx)
movl 0xc(%rsp), %esi
testl %esi, %esi
jle 0x91a7
movq %r14, %rcx
addq $0x14, %rcx
addq $0x10, %rax
xorl %edx, %edx
movl 0xc(%rcx), %esi
imull 0x8(%rcx), %esi
movups (%rcx), %xmm0
movups %xmm0, -0x10(%rax)
movl %esi, (%rax)
incq %rdx
movslq 0xc(%rsp), %rsi
addq $0x38, %rcx
addq $0x14, %rax
cmpq %rsi, %rdx
jl 0x9182
movl %esi, 0x6c(%rbx)
movq %r14, %rdi
callq 0x4300
jmp 0x91fe
movl $0x1, 0x6c(%rbx)
movq 0x70(%rbx), %rax
testq %rax, %rax
jne 0x91d2
movl $0x14, %edi
callq 0x9eb8
movq %rax, 0x70(%rbx)
movq $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)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x92f2
leaq 0x6603(%rip), %rax      # 0xf8f0
cmpl %ebp, 0x2c(%rax)
jbe 0x92f7
cmpl %ebp, 0x60(%rbx)
jne 0x92fc
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x641d(%rip), %rax      # 0xf720
movq (%rax), %rax
testq %rax, %rax
je 0x9318
cmpl $-0x1, 0x20(%rax)
je 0x9318
xorl %edi, %edi
callq 0x5780
leaq 0x63e9(%rip), %rax      # 0xf708
movq (%rax), %r14
testq %r14, %r14
je 0x935d
movq 0x8(%r14), %rdi
cmpq %rbx, 0x10(%rdi)
jne 0x9358
movl 0x20(%rdi), %eax
cmpl 0x60(%rbx), %eax
jne 0x9340
callq 0x5524
jmp 0x9358
cmpl %ebp, %eax
jne 0x9358
cmpl $0x0, 0x94(%rdi)
je 0x9353
cmpl $0x0, 0x68(%rbx)
je 0x9358
callq 0x55bc
movq (%r14), %r14
jmp 0x9322
movl 0x60(%rbx), %eax
movl %eax, 0x64(%rbx)
movl %ebp, 0x60(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7e4a
// File: /workspace/github_c_makefile_star2_O3/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, 0x68(%rdi)
leaq 0x6384(%rip), %rax      # 0xf708
movq (%rax), %r12
testq %r12, %r12
je 0x93e0
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r12), %r15
cmpq %r14, 0x10(%r15)
je 0x93a7
movq (%r12), %r12
testq %r12, %r12
jne 0x9391
jmp 0x93e0
cmpl $0x0, 0x94(%r15)
je 0x939c
testl %ebx, %ebx
je 0x93d6
movl 0x20(%r15), %eax
cmpl $-0x1, %eax
je 0x93c4
cmpl 0x60(%r14), %eax
jne 0x939c
movq %r15, %rdi
callq 0x55bc
movq %r15, %rdi
callq 0x5611
jmp 0x939c
movq %r15, %rdi
callq 0x5524
jmp 0x939c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x6310(%rip), %rax      # 0xf708
movq (%rax), %r15
testq %r15, %r15
je 0x9468
movq %rdi, %rbx
movq 0x8(%r15), %r14
cmpq %rbx, 0x10(%r14)
jne 0x9460
movq %r14, %rdi
xorl %esi, %esi
callq 0x5371
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)
movq (%r15), %r15
testq %r15, %r15
jne 0x9403
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x628b(%rip), %rax      # 0xf708
movq (%rax), %r12
testq %r12, %r12
je 0x9593
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movq 0x8(%r12), %r15
cmpq %rbx, 0x10(%r15)
jne 0x9540
movq %r15, %rdi
movq %r14, %rsi
callq 0x5371
cmpl $0x0, 0x48(%r15)
je 0x94ea
movl (%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subl 0x3c(%r15), %ecx
movl %ecx, 0x28(%r15)
movl 0x8(%rax), %ecx
movl %ecx, 0x30(%r15)
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x58(%r15), %xmm0
addsd %xmm1, %xmm0
movl $0x40, %ecx
cvttsd2si %xmm0, %edx
movl %edx, (%r15,%rcx)
jmp 0x94f1
cmpl $0x0, 0x4(%rsp)
je 0x954f
cmpl $0x0, 0x4c(%r15)
je 0x9531
movl 0x4(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subl 0x3c(%r15), %ecx
movl %ecx, 0x2c(%r15)
movl 0xc(%rax), %eax
movl %eax, 0x34(%r15)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x60(%r15), %xmm0
addsd %xmm1, %xmm0
movl $0x44, %eax
cvttsd2si %xmm0, %ecx
movl %ecx, (%r15,%rax)
jmp 0x9538
cmpl $0x0, 0x4(%rsp)
je 0x9572
movq %r15, %rdi
callq 0x67ab
movq (%r12), %r12
testq %r12, %r12
jne 0x9491
jmp 0x9593
xorps %xmm1, %xmm1
cvtsi2sdl (%rax), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rax), %xmm0
mulsd 0x58(%r15), %xmm0
addsd %xmm1, %xmm0
movl $0x28, %ecx
jmp 0x94e0
xorps %xmm1, %xmm1
cvtsi2sdl 0x4(%rax), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rax), %xmm0
mulsd 0x60(%r15), %xmm0
addsd %xmm1, %xmm0
movl $0x2c, %eax
jmp 0x9527
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6182(%rip), %rax      # 0xf728
movslq 0x188(%rax), %rcx
testq %rcx, %rcx
jle 0x95c8
movq 0x190(%rax), %rax
cmpq %rdi, 0x10(%rax)
je 0x95ca
addq $0x78, %rax
decq %rcx
jne 0x95b9
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/screen.c
// Function: find_current_screen
struct screen *find_current_screen(void) {
	Window cur_root;
	Window dw;  // dummy
	int di;  // dummy
	unsigned dui;  // dummy

	// XQueryPointer is useful for getting the current pointer root
	XQueryPointer(display.dpy, display.screens[0].root, &cur_root, &dw, &di, &di, &di, &di, &dui);
	return find_screen(cur_root);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x6151(%rip), %rbx      # 0xf728
movq (%rbx), %rdi
movq 0x190(%rbx), %rax
movq 0x10(%rax), %rsi
subq $0x8, %rsp
leaq 0x18(%rsp), %rax
leaq 0x1c(%rsp), %r8
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r8, %r9
pushq %rax
pushq %r8
pushq %r8
callq 0x4600
addq $0x20, %rsp
movslq 0x188(%rbx), %rcx
testq %rcx, %rcx
jle 0x9635
movq 0x8(%rsp), %rdx
movq 0x190(%rbx), %rax
cmpq %rdx, 0x10(%rax)
je 0x9637
addq $0x78, %rax
decq %rcx
jne 0x9626
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x95cb
testq %rax, %rax
je 0x965c
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x965c
callq 0x4470
callq 0x4680
testl %eax, %eax
je 0x966f
jle 0x9689
xorl %edi, %edi
popq %rbx
jmp 0x40d0
callq 0x40b0
callq 0x4680
testl %eax, %eax
jne 0x968b
movq (%rbx), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x4150
popq %rbx
retq
xorl %edi, %edi
callq 0x4230
// File: /workspace/github_c_makefile_star2_O3/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 0x610a(%rip), %rax      # 0xf8f0
movl 0x28(%rax), %ebx
leaq 0x5f38(%rip), %rax      # 0xf728
movq 0x28(%rax), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, %rsi
callq 0x975a
testq %rax, %rax
je 0x9824
cmpq $0x3, 0x8(%rsp)
jb 0x981c
testb $0x2, (%rax)
je 0x981c
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_O3/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, %rbx
leaq 0x5ee1(%rip), %r12      # 0xf728
movq (%r12), %rdi
movl 0x10(%rdi), %r14d
callq 0x4760
testl %eax, %eax
je 0x986e
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x43d0
movl $0x1, %eax
jmp 0x98ff
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r14d, %ecx
subl %edx, %ecx
movl $0x1, %r13d
shlq %cl, %r13
sarl $0x6, %eax
movslq %eax, %rbp
incl %r14d
movq %rsp, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
orq %r13, (%rsp,%rbp,8)
movl %r14d, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4140
testl %eax, %eax
jns 0x98eb
callq 0x44d0
cmpl $0x4, (%rax)
je 0x98fd
callq 0x4915
movq (%r12), %rdi
callq 0x4760
testl %eax, %eax
je 0x9898
jmp 0x9858
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
leaq 0x5dfe(%rip), %r12      # 0xf728
movq (%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x4500
movq (%r12), %rdi
movq %rsp, %rdx
movl $0x10, %esi
callq 0x4430
testl %eax, %eax
je 0x99a1
leaq 0xc0(%rsp), %r14
movq %rsp, %r15
movq 0x20(%rsp), %rax
cmpq 0x8(%rbx), %rax
jne 0x9977
movl $0xc0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4740
movl $0x1, %ebp
movq (%r12), %rdi
movl $0x10, %esi
movq %r15, %rdx
callq 0x4430
testl %eax, %eax
jne 0x9957
testl %ebp, %ebp
je 0x99a1
movq (%r12), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4460
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x99d0
movzbl %cl, %eax
testl %eax, %eax
je 0x99eb
cmpl $0x23, %eax
jne 0x99f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x9f30
movq %rax, %rbx
leaq 0x1983(%rip), %rsi      # 0xb38c
movq %rax, %rdi
callq 0x4580
testq %rax, %rax
je 0x9a8d
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x9aa0
testq %rax, %rax
je 0x9a56
movq %rax, %r15
cmpl $0x4, (%rax)
jne 0x9a69
leaq 0x1979(%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 0x9a45
jmp 0x9a77
leaq 0x1936(%rip), %rdi      # 0xb393
movq %r12, %rsi
xorl %eax, %eax
callq 0x4060
jmp 0x9a8d
leaq 0x191c(%rip), %rsi      # 0xb38c
xorl %edi, %edi
callq 0x4580
testq %rax, %rax
leaq 0xf92(%rip), %rsi       # 0xaa13
cmovneq %rax, %rsi
movq %r15, %rdi
callq 0x9ad6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/xconfig.c
// Function: find_option
static struct xconfig_option *find_option(struct xconfig_option *options,
		const char *opt) {
	for (int i = 0; options[i].type != XCONFIG_END; i++) {
		if (0 == strcmp(options[i].name, opt)) {
			return &options[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x7, (%rdi)
je 0x9ac9
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4540
testl %eax, %eax
je 0x9acb
cmpl $0x7, 0x18(%rbx)
leaq 0x18(%rbx), %rbx
jne 0x9aaf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x55c(%rip), %rsi       # 0xa26b
movq %rax, %rdi
callq 0x41f0
testq %rax, %rax
je 0x9d63
movq %rax, %r14
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x42a0
testq %rax, %rax
je 0x9d57
movq %rsp, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99b4
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x42a0
testq %rax, %rax
jne 0x9d37
movq %r14, %rdi
callq 0x45f0
xorl %eax, %eax
jmp 0x9d68
movl $0x3, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testq %rcx, %rcx
je 0x9d95
movl (%rbx), %r12d
jmp 0x9d9b
movl $0x1, %r12d
cmpl %ebp, %r12d
jge 0x9e1b
movslq %r12d, %rax
movq (%r14,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x9e1b
movzbl 0x1(%rsi), %eax
subl $0x2d, %eax
jne 0x9db9
movzbl 0x2(%rsi), %eax
negl %eax
testl %eax, %eax
je 0x9e18
cmpb $0x2d, 0x1(%rsi)
je 0x9dca
incq %rsi
jmp 0x9dce
addq $0x2, %rsi
movq %r15, %rdi
callq 0x9aa0
testq %rax, %rax
je 0x9e34
movl (%rax), %ecx
movl $0x1, %r13d
testl %ecx, %ecx
je 0x9e09
movl $0x0, %esi
cmpl $0x5, %ecx
je 0x9e0b
leal 0x1(%r12), %ecx
cmpl %ebp, %ecx
jge 0x9e3b
movslq %ecx, %rcx
movq (%r14,%rcx,8), %rsi
movl $0x2, %r13d
jmp 0x9e0b
xorl %esi, %esi
movq %rax, %rdi
callq 0x9ad6
addl %r13d, %r12d
jmp 0x9d9b
incl %r12d
xorl %eax, %eax
testq %rbx, %rbx
je 0x9e25
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x9e1d
movl $0x2, %eax
jmp 0x9e1d
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/xconfig.c
// Function: unset_option
static void unset_option(struct xconfig_option *option) {
	switch (option->type) {
	case XCONFIG_STRING:
		if (*(char **)option->dest.s) {
			free(*(char **)option->dest.s);
			*(char **)option->dest.s = NULL;
		}
		break;
	case XCONFIG_STR_LIST:
		if (*(char ***)option->dest.sl) {
			if ((*(char ***)option->dest.sl)[0]) {
				free((*(char ***)option->dest.sl)[0]);
			}
			free(*(char ***)option->dest.sl);
			*(char ***)option->dest.sl = NULL;
		}
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x4, %eax
je 0x9e81
cmpl $0x3, %eax
jne 0x9eb6
movq 0x10(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9eb6
addq $0x10, %rbx
jmp 0x9ea7
movq 0x10(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9eb6
addq $0x10, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x9ea7
movq %rax, %rdi
callq 0x42d0
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x42d0
movq (%rbx), %rax
movq $0x0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/xmalloc.c
// Function: xmalloc
void *xmalloc(size_t s) {
	void *mem = malloc(s);
	if (!mem) {
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	return mem;
}

// Assembly:
pushq %rax
callq 0x41e0
testq %rax, %rax
je 0x9ec5
popq %rcx
retq
callq 0x4937
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/xmalloc.c
// Function: xrealloc
void *xrealloc(void *p, size_t s) {
	void *mem = realloc(p, s);
	if (!mem && s != 0) {
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	return mem;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x46c0
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x9efc
popq %rbx
retq
callq 0x4947
// File: /workspace/github_c_makefile_star2_O3/mati75[P]evilwm/xmalloc.c
// Function: xstrdup
void *xmemdup(const void *p, size_t s) {
	if (!p)
		return NULL;
	void *mem = xmalloc(s);
	memcpy(mem, p, s);
	return mem;
}

// Assembly:
testq %rdi, %rdi
je 0x9f62
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x42f0
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x9eb8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4740
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jacereda[P]fsatrace/src/fsatrace.c
// Function: dump
static void
dump(const char *path, char *p, size_t sz)
{
	int	fd;
	ssize_t r = 0;
	if (strcmp(path, "-"))
		fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0777);
	else
		fd = 1;
	if (fd >= 0)
		r = write(fd, p, sz);
	else
		error("Unable to open output file '%s'", path);
	if (r != sz)
		error("Short write (%d/%d)", r, sz);
	if (fd != 1)
		close(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x2d, (%rdi)
jne 0x18ca
cmpb $0x0, 0x1(%r15)
je 0x18fa
movq %r15, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x11a0
movl %eax, %ebp
testl %eax, %eax
jns 0x18ff
leaq 0x970(%rip), %rdi       # 0x225b
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq 0x1949
jmp 0x190f
movl $0x1, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1090
movq %rax, %r14
cmpq %rbx, %r14
je 0x1928
leaq 0x960(%rip), %rdi       # 0x227b
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1949
cmpl $0x1, %ebp
jne 0x1938
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O3/jacereda[P]fsatrace/src/unix/proc.c
// Function: procPath
void
procPath(char *fullpath)
{
#if defined __linux__
	char	exepath[64];
	ssize_t ret;
	snprintf(exepath, sizeof(exepath), "/proc/%d/exe", getpid());
	ret = readlink(exepath, fullpath, PATH_MAX);
	assert(ret != -1);
	fullpath[ret] = 0;
#else
	proc_pidpath(getpid(), fullpath, PATH_MAX);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x10a0
leaq 0x8a1(%rip), %rdx       # 0x228f
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x10e0
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
cmpq $-0x1, %rax
je 0x1a24
movb $0x0, (%rbx,%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x871(%rip), %rdi       # 0x229c
leaq 0x874(%rip), %rsi       # 0x22a6
leaq 0x87d(%rip), %rcx       # 0x22b6
movl $0x16, %edx
callq 0x1100