LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/pointer.c
// Function: grab_buttons
void grab_buttons(void)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
				window_grab_buttons(n->id);
				if (n->presel != NULL) {
					window_grab_buttons(n->presel->feedback);
				}
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a277(%rip), %r14     # 0x28708
movq (%r14), %r14
testq %r14, %r14
je 0xe4e8
leaq 0x60(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xe4e2
movq 0x30(%r15), %rdi
callq 0x8e72
movq %rax, %rbx
testq %rax, %rax
je 0xe4dc
movl (%rbx), %edi
callq 0xe1a9
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xe4ce
movl 0xc(%rax), %edi
callq 0xe1a9
movq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x8ed0
jmp 0xe4ae
addq $0x48, %r15
jmp 0xe49d
addq $0x78, %r14
jmp 0xe491
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/pointer.c
// Function: ungrab_buttons
void ungrab_buttons(void)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
				xcb_ungrab_button(dpy, XCB_BUTTON_INDEX_ANY, n->id, XCB_MOD_MASK_ANY);
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1a20b(%rip), %r14     # 0x28708
leaq 0x1a1c4(%rip), %r15     # 0x286c8
movq (%r14), %r14
testq %r14, %r14
je 0xe557
leaq 0x60(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xe551
movq 0x30(%r12), %rdi
callq 0x8e72
movq %rax, %rbx
testq %rax, %rax
je 0xe54b
movq (%r15), %rdi
movl (%rbx), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0x4840
movq 0x30(%r12), %rsi
movq %rbx, %rdi
callq 0x8ed0
jmp 0xe523
addq $0x48, %r12
jmp 0xe510
addq $0x78, %r14
jmp 0xe504
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/pointer.c
// Function: get_handle
resize_handle_t get_handle(node_t *n, xcb_point_t pos, pointer_action_t pac)
{
	resize_handle_t rh = HANDLE_BOTTOM_RIGHT;
	xcb_rectangle_t rect = get_rectangle(NULL, NULL, n);
	if (pac == ACTION_RESIZE_SIDE) {
		float W = rect.width;
		float H = rect.height;
		float ratio = W / H;
		float x = pos.x - rect.x;
		float y = pos.y - rect.y;
		float diag_a = ratio * y;
		float diag_b = W - diag_a;
		if (x < diag_a) {
			if (x < diag_b) {
				rh = HANDLE_LEFT;
			} else {
				rh = HANDLE_BOTTOM;
			}
		} else {
			if (x < diag_b) {
				rh = HANDLE_TOP;
			} else {
				rh = HANDLE_RIGHT;
			}
		}
	} else if (pac == ACTION_RESIZE_CORNER) {
		int16_t mid_x = rect.x + (rect.width / 2);
		int16_t mid_y = rect.y + (rect.height / 2);
		if (pos.x > mid_x) {
			if (pos.y > mid_y) {
				rh = HANDLE_BOTTOM_RIGHT;
			} else {
				rh = HANDLE_TOP_RIGHT;
			}
		} else {
			if (pos.y > mid_y) {
				rh = HANDLE_BOTTOM_LEFT;
			} else {
				rh = HANDLE_TOP_LEFT;
			}
		}
	}
	return rh;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x932e
movl %eax, %ecx
shrl $0x10, %ecx
cmpl $0x4, %ebp
je 0xe5e4
cmpl $0x3, %ebp
jne 0xe612
movq %rax, %rdx
movq %rax, %rsi
shrq $0x20, %rsi
movzwl %si, %esi
cvtsi2ss %esi, %xmm0
shrq $0x30, %rdx
cvtsi2ss %edx, %xmm1
movswl %bx, %edx
cwtl
subl %eax, %edx
cvtsi2ss %edx, %xmm2
sarl $0x10, %ebx
movswl %cx, %eax
subl %eax, %ebx
cvtsi2ss %ebx, %xmm3
movaps %xmm0, %xmm4
divss %xmm1, %xmm4
mulss %xmm4, %xmm3
subss %xmm3, %xmm0
xorl %eax, %eax
ucomiss %xmm2, %xmm0
pushq $0x1
popq %rcx
pushq $0x8
popq %rdx
cmoval %ecx, %edx
setbe %al
ucomiss %xmm2, %xmm3
leal 0x2(%rax,%rax), %eax
cmoval %edx, %eax
jmp 0xe622
movq %rax, %rdx
shrq $0x21, %rdx
andl $0x7fff, %edx           # imm = 0x7FFF
addl %eax, %edx
shrq $0x31, %rax
addl %eax, %ecx
movswl %bx, %esi
movswl %dx, %edx
sarl $0x10, %ebx
movswl %cx, %eax
cmpl %edx, %esi
jle 0xe617
cmpl %eax, %ebx
pushq $0xc
popq %rcx
pushq $0x6
jmp 0xe61e
pushq $0xc
popq %rax
jmp 0xe622
cmpl %eax, %ebx
pushq $0x9
popq %rcx
pushq $0x3
popq %rax
cmovgl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: schedule_window
void schedule_window(xcb_window_t win)
{
	coordinates_t loc;
	uint8_t override_redirect = 0;
	xcb_get_window_attributes_reply_t *wa = xcb_get_window_attributes_reply(dpy, xcb_get_window_attributes(dpy, win), NULL);

	if (wa != NULL) {
		override_redirect = wa->override_redirect;
		free(wa);
	}

	if (override_redirect || locate_window(win, &loc)) {
		return;
	}

	/* ignore pending windows */
	for (pending_rule_t *pr = pending_rule_head; pr != NULL; pr = pr->next) {
		if (pr->win == win) {
			return;
		}
	}

	rule_consequence_t *csq = make_rule_consequence();
	apply_rules(win, csq);
	if (!schedule_rules(win, csq)) {
		manage_window(win, csq, -1);
		free(csq);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x19ba7(%rip), %rax     # 0x286c8
movq (%rax), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x4810
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x44b0
testq %rax, %rax
je 0xeb50
movb 0x1b(%rax), %bpl
movq %rax, %rdi
callq 0x4460
testb %bpl, %bpl
jne 0xebaf
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x199cc
testb %al, %al
jne 0xebaf
leaq 0x19b71(%rip), %rax     # 0x286d8
movq (%rax), %rcx
testq %rcx, %rcx
je 0xeb7a
leaq 0x28(%rcx), %rax
cmpl %ebx, 0x4(%rcx)
jne 0xeb67
jmp 0xebaf
callq 0x1b81d
movq %rax, %r14
movl %ebx, %edi
movq %rax, %rsi
callq 0x1c19c
movl %ebx, %edi
movq %r14, %rsi
callq 0x1c2cc
testb %al, %al
jne 0xebaf
pushq $-0x1
popq %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0xebb8
movq %r14, %rdi
callq 0x4460
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: initialize_floating_rectangle
void initialize_floating_rectangle(node_t *n)
{
	client_t *c = n->client;

	xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply(dpy, xcb_get_geometry(dpy, n->id), NULL);

	if (geo != NULL) {
		c->floating_rectangle = (xcb_rectangle_t) {geo->x, geo->y, geo->width, geo->height};
	}

	free(geo);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r14
leaq 0x1953c(%rip), %rax     # 0x286c8
movq (%rax), %rbx
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x45c0
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x46a0
testq %rax, %rax
je 0xf1b5
movq 0xc(%rax), %rcx
movq %rcx, 0x318(%r14)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: window_center
void window_center(monitor_t *m, client_t *c)
{
	xcb_rectangle_t *r = &c->floating_rectangle;
	xcb_rectangle_t a = m->rectangle;
	if (r->width >= a.width) {
		r->x = a.x;
	} else {
		r->x = a.x + (a.width - r->width) / 2;
	}
	if (r->height >= a.height) {
		r->y = a.y;
	} else {
		r->y = a.y + (a.height - r->height) / 2;
	}
	r->x -= c->border_width;
	r->y -= c->border_width;
}

// Assembly:
movzwl 0x4c(%rdi), %r9d
movzwl 0x4e(%rdi), %r8d
movzwl 0x50(%rdi), %eax
movzwl 0x52(%rdi), %ecx
movzwl 0x31c(%rsi), %edx
pushq $0x2
popq %rdi
cmpw %ax, %dx
jae 0xf1ed
subl %edx, %eax
cltd
idivl %edi
addl %eax, %r9d
movzwl 0x31e(%rsi), %eax
cmpw %cx, %ax
jae 0xf203
subl %eax, %ecx
movl %ecx, %eax
cltd
idivl %edi
addl %eax, %r8d
movl 0x300(%rsi), %eax
subl %eax, %r9d
movw %r9w, 0x318(%rsi)
subl %eax, %r8d
movw %r8w, 0x31a(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: draw_border
void draw_border(node_t *n, bool focused_node, bool focused_monitor)
{
	if (n == NULL) {
		return;
	}

	uint32_t border_color_pxl = get_border_color(focused_node, focused_monitor);
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (f->client != NULL) {
			window_draw_border(f->id, border_color_pxl);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0xf2a9
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl %sil, %edi
movzbl %dl, %esi
callq 0xf813
movl %eax, %ebp
movq %rbx, %rdi
callq 0x8e72
movq %rax, %r14
testq %rax, %rax
je 0xf2a5
cmpq $0x0, 0x48(%r14)
je 0xf298
movl (%r14), %edi
movl %ebp, %esi
callq 0xf83d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8ed0
jmp 0xf27f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: unmanage_window
void unmanage_window(xcb_window_t win)
{
	coordinates_t loc;
	if (locate_window(win, &loc)) {
		put_status(SBSC_MASK_NODE_REMOVE, "node_remove 0x%08X 0x%08X 0x%08X\n", loc.monitor->id, loc.desktop->id, win);
		remove_node(loc.monitor, loc.desktop, loc.node);
		arrange(loc.monitor, loc.desktop);
	} else {
		for (pending_rule_t *pr = pending_rule_head; pr != NULL; pr = pr->next) {
			if (pr->win == win) {
				remove_pending_rule(pr);
				return;
			}
		}
	}
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %rsi
callq 0x199cc
testb %al, %al
je 0xf30a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x20(%rax), %edx
movl 0x20(%rcx), %ecx
leaq 0xf497(%rip), %rsi      # 0x1e76d
movl $0x10000, %edi          # imm = 0x10000
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1d07d
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb13d
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8670
jmp 0xf329
leaq 0x193c7(%rip), %rdi     # 0x286d8
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xf329
cmpl %ebx, 0x4(%rdi)
je 0xf324
addq $0x28, %rdi
jmp 0xf311
callq 0x1b8a1
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: is_presel_window
bool is_presel_window(xcb_window_t win)
{
	xcb_icccm_get_wm_class_reply_t reply;
	bool ret = false;
	if (xcb_icccm_get_wm_class_reply(dpy, xcb_icccm_get_wm_class(dpy, win), &reply, NULL) == 1) {
		if (streq(BSPWM_CLASS_NAME, reply.class_name) && streq(PRESEL_FEEDBACK_I, reply.instance_name)) {
			ret = true;
		}
		xcb_icccm_get_wm_class_reply_wipe(&reply);
	}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %esi
leaq 0x19389(%rip), %rax     # 0x286c8
movq (%rax), %r14
movq %r14, %rdi
callq 0x4940
xorl %ebx, %ebx
movq %rsp, %rdx
movq %r14, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x4a20
cmpb $0x1, %al
jne 0xf395
movq 0x8(%rsp), %rsi
leaq 0xf86b(%rip), %rdi      # 0x1ebd6
callq 0x4820
testl %eax, %eax
je 0xf378
xorl %ebx, %ebx
jmp 0xf38d
movq (%rsp), %rsi
leaq 0xf859(%rip), %rdi      # 0x1ebdc
callq 0x4820
testl %eax, %eax
sete %bl
movq %rsp, %rdi
callq 0x4480
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: initialize_presel_feedback
void initialize_presel_feedback(node_t *n)
{
	if (n == NULL || n->presel == NULL || n->presel->feedback != XCB_NONE) {
		return;
	}

	xcb_window_t win = xcb_generate_id(dpy);
	uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_SAVE_UNDER;
	uint32_t values[] = {get_color_pixel(presel_feedback_color), 1};
	xcb_create_window(dpy, XCB_COPY_FROM_PARENT, win, root, 0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
			          XCB_COPY_FROM_PARENT, mask, values);

	xcb_icccm_set_wm_class(dpy, win, sizeof(PRESEL_FEEDBACK_IC), PRESEL_FEEDBACK_IC);
	/* Make presel window's input shape NULL to pass any input to window below */
	xcb_shape_rectangles(dpy, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_CLIP_ORDERING_UNSORTED, win, 0, 0, 0, NULL);
	stacking_list_t *s = stack_tail;
	while (s != NULL && !IS_TILED(s->node->client)) {
		s = s->prev;
	}
	if (s != NULL) {
		window_above(win, s->node->id);
	}
	n->presel->feedback = win;
}

// Assembly:
testq %rdi, %rdi
je 0xf4a4
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf49c
cmpl $0x0, 0xc(%rax)
jne 0xf49c
leaq 0x192f7(%rip), %r14     # 0x286c8
movq (%r14), %rdi
callq 0x4920
movl %eax, %ebp
leaq 0x198be(%rip), %rdi     # 0x28ca0
callq 0x5afb
leaq 0x38(%rsp), %rdx
movl %eax, (%rdx)
pushq $0x1
popq %rax
movl %eax, 0x4(%rdx)
movq (%r14), %rdi
leaq 0x1937a(%rip), %rcx     # 0x28778
movl (%rcx), %ecx
movq %rdx, 0x30(%rsp)
movl %eax, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
movl %eax, 0x8(%rsp)
andl $0x0, 0x10(%rsp)
movl %eax, (%rsp)
movl $0x402, 0x28(%rsp)      # imm = 0x402
xorl %esi, %esi
movl %ebp, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4030
movq (%r14), %rdi
leaq 0xf785(%rip), %rcx      # 0x1ebc0
pushq $0x16
popq %rdx
movl %ebp, %esi
callq 0x4710
movq (%r14), %rdi
andq $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x2
popq %rdx
xorl %esi, %esi
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x4410
leaq 0x192d0(%rip), %rax     # 0x28740
movq (%rax), %rax
testq %rax, %rax
je 0xf495
movq (%rax), %rcx
movq 0x48(%rcx), %rdx
addq $0x8, %rax
cmpl $0x1, 0x308(%rdx)
ja 0xf470
movl (%rcx), %esi
movl %ebp, %edi
callq 0xf4a5
movq 0x10(%rbx), %rax
movl %ebp, 0xc(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: draw_presel_feedback
void draw_presel_feedback(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL || n->presel == NULL || d->user_layout == LAYOUT_MONOCLE || !presel_feedback) {
		return;
	}

	bool exists = (n->presel->feedback != XCB_NONE);
	if (!exists) {
		initialize_presel_feedback(n);
	}

	int gap = gapless_monocle && d->layout == LAYOUT_MONOCLE ? 0 : d->window_gap;
	presel_t *p = n->presel;
	xcb_rectangle_t rect = n->rectangle;
	rect.x = rect.y = 0;
	rect.width -= gap;
	rect.height -= gap;
	xcb_rectangle_t presel_rect = rect;

	switch (p->split_dir) {
		case DIR_NORTH:
			presel_rect.height = p->split_ratio * rect.height;
			break;
		case DIR_EAST:
			presel_rect.width = (1 - p->split_ratio) * rect.width;
			presel_rect.x = rect.width - presel_rect.width;
			break;
		case DIR_SOUTH:
			presel_rect.height = (1 - p->split_ratio) * rect.height;
			presel_rect.y = rect.height - presel_rect.height;
			break;
		case DIR_WEST:
			presel_rect.width = p->split_ratio * rect.width;
			break;
	}

	window_move_resize(p->feedback, n->rectangle.x + presel_rect.x, n->rectangle.y + presel_rect.y,
	                   presel_rect.width, presel_rect.height);

	if (!exists && m->desk == d) {
		window_show(p->feedback);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xf5e7
movq %rdx, %r15
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0xf5e7
movq %rsi, %rbx
cmpl $0x1, 0x28(%rsi)
je 0xf5e7
leaq 0x19914(%rip), %rcx     # 0x28df5
cmpb $0x1, (%rcx)
jne 0xf5e7
movq %rdi, %r14
movl 0xc(%rax), %ebp
testl %ebp, %ebp
jne 0xf4fc
movq %r15, %rdi
callq 0xf39f
leaq 0x198f4(%rip), %rax     # 0x28df7
cmpb $0x1, (%rax)
jne 0xf512
cmpl $0x1, 0x24(%rbx)
jne 0xf512
xorl %edx, %edx
jmp 0xf516
movzwl 0x60(%rbx), %edx
movq 0x10(%r15), %r12
movl 0x1c(%r15), %ecx
movzwl 0x1e(%r15), %eax
subl %edx, %ecx
subl %edx, %eax
movl 0x8(%r12), %edx
cmpq $0x3, %rdx
ja 0xf5b8
leaq 0xf673(%rip), %rsi      # 0x1ebb0
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movzwl %ax, %eax
cvtsi2sd %eax, %xmm0
mulsd (%r12), %xmm0
cvttsd2si %xmm0, %eax
jmp 0xf5b8
movsd 0xf0a7(%rip), %xmm0     # 0x1e608
subsd (%r12), %xmm0
movzwl %ax, %edx
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edi
subl %edi, %eax
movl %eax, %edx
xorl %esi, %esi
movl %edi, %eax
jmp 0xf5bc
movsd 0xf080(%rip), %xmm0     # 0x1e608
subsd (%r12), %xmm0
movzwl %cx, %edx
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edi
subl %edi, %ecx
movl %ecx, %esi
xorl %edx, %edx
movl %edi, %ecx
jmp 0xf5bc
movzwl %cx, %ecx
cvtsi2sd %ecx, %xmm0
mulsd (%r12), %xmm0
cvttsd2si %xmm0, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl 0xc(%r12), %edi
addw 0x18(%r15), %si
addw 0x1a(%r15), %dx
movswl %si, %esi
movswl %dx, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0xf602
testl %ebp, %ebp
jne 0xf5e7
cmpq %rbx, 0x58(%r14)
je 0xf5f0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%r12), %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf175
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: refresh_presel_feedbacks
void refresh_presel_feedbacks(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	} else {
		if (n->presel != NULL) {
			draw_presel_feedback(m, d, n);
		}
		refresh_presel_feedbacks(m, d, n->first_child);
		refresh_presel_feedbacks(m, d, n->second_child);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0xf673
cmpq $0x0, 0x10(%rbx)
je 0xf65e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf4ac
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf636
movq 0x38(%rbx), %rbx
jmp 0xf644
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: show_presel_feedbacks
void show_presel_feedbacks(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	} else {
		if (n->presel != NULL) {
			window_show(n->presel->feedback);
		}
		show_presel_feedbacks(m, d, n->first_child);
		show_presel_feedbacks(m, d, n->second_child);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0xf6b2
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xf69d
movl 0xc(%rax), %edi
callq 0xf175
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf679
movq 0x38(%rbx), %rbx
jmp 0xf687
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: hide_presel_feedbacks
void hide_presel_feedbacks(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	} else {
		if (n->presel != NULL) {
			window_hide(n->presel->feedback);
		}
		hide_presel_feedbacks(m, d, n->first_child);
		hide_presel_feedbacks(m, d, n->second_child);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0xf6f1
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xf6dc
movl 0xc(%rax), %edi
callq 0xf6f7
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf6b8
movq 0x38(%rbx), %rbx
jmp 0xf6c6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: update_colors_in
void update_colors_in(node_t *n, desktop_t *d, monitor_t *m)
{
	if (n == NULL) {
		return;
	} else {
		if (n->presel != NULL) {
			uint32_t pxl = get_color_pixel(presel_feedback_color);
			xcb_change_window_attributes(dpy, n->presel->feedback, XCB_CW_BACK_PIXEL, &pxl);
			if (d == m->desk) {
				/* hack to induce back pixel refresh */
				window_hide(n->presel->feedback);
				window_show(n->presel->feedback);
			}
		}
		if (n == d->focus) {
			draw_border(n, true, (m == mon));
		} else if (n->client != NULL) {
			draw_border(n, false, (m == mon));
		} else {
			update_colors_in(n->first_child, d, m);
			update_colors_in(n->second_child, d, m);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0xf812
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0xf7ac
leaq 0x19537(%rip), %rdi     # 0x28ca0
callq 0x5afb
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x18f4c(%rip), %rax     # 0x286c8
movq (%rax), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
pushq $0x2
popq %rdx
callq 0x4700
cmpq %r15, 0x58(%r14)
jne 0xf7ac
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
callq 0xf6f7
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
callq 0xf175
cmpq %rbx, 0x38(%r15)
je 0xf7cf
cmpq $0x0, 0x48(%rbx)
je 0xf7eb
leaq 0x18f50(%rip), %rax     # 0x28710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %rbx, %rdi
xorl %esi, %esi
jmp 0xf7e4
leaq 0x18f3a(%rip), %rax     # 0x28710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf25d
jmp 0xf809
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf740
movq 0x38(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf740
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: adopt_orphans
void adopt_orphans(void)
{
	xcb_query_tree_reply_t *qtr = xcb_query_tree_reply(dpy, xcb_query_tree(dpy, root), NULL);
	if (qtr == NULL) {
		return;
	}

	int len = xcb_query_tree_children_length(qtr);
	xcb_window_t *wins = xcb_query_tree_children(qtr);

	for (int i = 0; i < len; i++) {
		uint32_t idx;
		xcb_window_t win = wins[i];
		if (xcb_ewmh_get_wm_desktop_reply(ewmh, xcb_ewmh_get_wm_desktop(ewmh, win), &idx, NULL) == 1) {
			schedule_window(win);
		}
	}

	free(qtr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x18e56(%rip), %rax     # 0x286c8
movq (%rax), %r14
leaq 0x18efc(%rip), %rax     # 0x28778
movl (%rax), %esi
movq %r14, %rdi
callq 0x4350
xorl %ebx, %ebx
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x45b0
testq %rax, %rax
je 0xf909
movq %rax, %r15
movq %rax, %rdi
callq 0x4a70
movl %eax, %r14d
movq %r15, 0x8(%rsp)
movq %r15, %rdi
callq 0x47e0
movq %rax, %r15
testl %r14d, %r14d
cmovlel %ebx, %r14d
leaq 0x14(%rsp), %r12
cmpq %rbx, %r14
je 0xf8ff
movl (%r15,%rbx,4), %ebp
leaq 0x1955d(%rip), %rax     # 0x28e30
movq (%rax), %r13
movq %r13, %rdi
movl %ebp, %esi
callq 0x4740
movq %r13, %rdi
movl %eax, %esi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x4300
cmpb $0x1, %al
jne 0xf8fa
movl %ebp, %edi
callq 0xeb10
incq %rbx
jmp 0xf8c3
movq 0x8(%rsp), %rdi
callq 0x4460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: get_window_rectangle
xcb_rectangle_t get_window_rectangle(node_t *n)
{
	client_t *c = n->client;
	if (c != NULL) {
		xcb_get_geometry_reply_t *g = xcb_get_geometry_reply(dpy, xcb_get_geometry(dpy, n->id), NULL);
		if (g != NULL) {
			xcb_rectangle_t rect = (xcb_rectangle_t) {g->x, g->y, g->width, g->height};
			free(g);
			return rect;
		}
	}
	return (xcb_rectangle_t) {0, 0, screen_width, screen_height};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x48(%rdi)
je 0xf96b
leaq 0x18d9b(%rip), %rax     # 0x286c8
movq (%rax), %rbx
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x45c0
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x46a0
testq %rax, %rax
je 0xf96b
movzwl 0xc(%rax), %ebx
movzwl 0x10(%rax), %ebp
movzwl 0x12(%rax), %r15d
movzwl 0xe(%rax), %r14d
movq %rax, %rdi
callq 0x4460
shll $0x10, %r14d
jmp 0xf985
leaq 0x18e0a(%rip), %rax     # 0x2877c
movzwl (%rax), %ebp
leaq 0x18e04(%rip), %rax     # 0x28780
movzwl (%rax), %r15d
xorl %ebx, %ebx
xorl %r14d, %r14d
movzwl %r15w, %ecx
shlq $0x30, %rcx
movzwl %bp, %eax
shlq $0x20, %rax
orq %rcx, %rax
orq %r14, %rax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: update_motion_recorder
void update_motion_recorder(void)
{
	xcb_point_t pt;
	xcb_window_t win = XCB_NONE;
	query_pointer(&win, &pt);
	if (win == XCB_NONE) {
		return;
	}
	monitor_t *m = monitor_from_point(pt);
	if (m == NULL) {
		return;
	}
	desktop_t *d = m->desk;
	node_t *n = NULL;
	for (n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
		if (n->id == win || (n->presel != NULL && n->presel->feedback == win)) {
			break;
		}
	}
	if ((n != NULL && n != mon->desk->focus) || (n == NULL && m != mon)) {
		enable_motion_recorder(win);
	} else {
		disable_motion_recorder();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
andl $0x0, (%rbx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xfb66
cmpl $0x0, (%rbx)
je 0x10391
movl 0x4(%rsp), %edi
callq 0x72fe
testq %rax, %rax
je 0x10391
movq %rax, %rbx
movq 0x58(%rax), %r14
movq 0x30(%r14), %rdi
callq 0x8e72
testq %rax, %rax
je 0x10376
movl (%rsp), %edi
cmpl %edi, (%rax)
je 0x10360
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x10352
cmpl %edi, 0xc(%rcx)
je 0x10360
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x8ed0
jmp 0x10338
leaq 0x183a9(%rip), %rcx     # 0x28710
movq (%rcx), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jne 0x10385
jmp 0x1038c
leaq 0x18393(%rip), %rax     # 0x28710
cmpq (%rax), %rbx
je 0x1038c
movl (%rsp), %edi
callq 0x10399
jmp 0x10391
callq 0x1041f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: enable_motion_recorder
void enable_motion_recorder(xcb_window_t win)
{
	xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply(dpy, xcb_get_geometry(dpy, win), NULL);
	if (geo != NULL) {
		uint16_t width = geo->width + 2 * geo->border_width;
		uint16_t height = geo->height + 2 * geo->border_width;
		window_move_resize(motion_recorder.id, geo->x, geo->y, width, height);
		window_above(motion_recorder.id, win);
		window_show(motion_recorder.id);
		motion_recorder.enabled = true;
	}
	free(geo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x18321(%rip), %rax     # 0x286c8
movq (%rax), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x45c0
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x46a0
movq %rax, %r14
testq %rax, %rax
je 0x10412
movl 0x14(%r14), %eax
addl %eax, %eax
movzwl 0x10(%r14), %ecx
addw %ax, %cx
addw 0x12(%r14), %ax
leaq 0x18306(%rip), %r15     # 0x286e8
movl (%r15), %edi
movswl 0xc(%r14), %esi
movswl 0xe(%r14), %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0xf602
movl (%r15), %edi
movl %ebx, %esi
callq 0xf4a5
movl (%r15), %edi
callq 0xf175
movb $0x1, 0x6(%r15)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: window_set_visibility
void window_set_visibility(xcb_window_t win, bool visible)
{
	uint32_t values_off[] = {ROOT_EVENT_MASK & ~XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY};
	uint32_t values_on[] = {ROOT_EVENT_MASK};
	xcb_change_window_attributes(dpy, root, XCB_CW_EVENT_MASK, values_off);
	if (visible) {
		set_window_state(win, XCB_ICCCM_WM_STATE_NORMAL);
		xcb_map_window(dpy, win);
	} else {
		xcb_unmap_window(dpy, win);
		set_window_state(win, XCB_ICCCM_WM_STATE_ICONIC);
	}
	xcb_change_window_attributes(dpy, root, XCB_CW_EVENT_MASK, values_on);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
leaq 0x4(%rsp), %rcx
movl $0x320004, (%rcx)       # imm = 0x320004
movl $0x3a0004, (%rsp)       # imm = 0x3A0004
leaq 0x181d7(%rip), %r14     # 0x286c8
movq (%r14), %rdi
leaq 0x1827d(%rip), %r15     # 0x28778
movl (%r15), %esi
movl $0x800, %edx            # imm = 0x800
callq 0x4700
testl %ebp, %ebp
je 0x10522
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0xf220
movq (%r14), %rdi
movl %ebx, %esi
callq 0x43e0
jmp 0x10536
movq (%r14), %rdi
movl %ebx, %esi
callq 0x4930
pushq $0x3
popq %rsi
movl %ebx, %edi
callq 0xf220
movq (%r14), %rdi
movl (%r15), %esi
movq %rsp, %rcx
movl $0x800, %edx            # imm = 0x800
callq 0x4700
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: set_input_focus
void set_input_focus(node_t *n)
{
	if (n == NULL || n->client == NULL) {
		clear_input_focus();
	} else {
		if (n->client->icccm_props.input_hint) {
			xcb_set_input_focus(dpy, XCB_INPUT_FOCUS_PARENT, n->id, XCB_CURRENT_TIME);
		} else if (n->client->icccm_props.take_focus) {
			send_client_message(n->id, ewmh->WM_PROTOCOLS, WM_TAKE_FOCUS);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x105cd
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x105cd
cmpb $0x1, 0x375(%rax)
jne 0x105a3
leaq 0x18137(%rip), %rax     # 0x286c8
movq (%rax), %rax
movl (%rdi), %edx
pushq $0x2
popq %rsi
movq %rax, %rdi
xorl %ecx, %ecx
jmp 0x4200
cmpb $0x1, 0x374(%rax)
jne 0x105cc
movl (%rdi), %edi
leaq 0x1887b(%rip), %rax     # 0x28e30
movq (%rax), %rax
movl 0xc8(%rax), %esi
leaq 0x181c7(%rip), %rax     # 0x2878c
movl (%rax), %edx
jmp 0x105ea
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: send_client_message
void send_client_message(xcb_window_t win, xcb_atom_t property, xcb_atom_t value)
{
	xcb_client_message_event_t *e = calloc(32, 1);

	e->response_type = XCB_CLIENT_MESSAGE;
	e->window = win;
	e->type = property;
	e->format = 32;
	e->data.data32[0] = value;
	e->data.data32[1] = XCB_CURRENT_TIME;

	xcb_send_event(dpy, false, win, XCB_EVENT_MASK_NO_EVENT, (char *) e);
	xcb_flush(dpy);
	free(e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x48b0
movq %rax, %r15
movw $0x2021, (%rax)         # imm = 0x2021
movl %r14d, 0x4(%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
leaq 0x180ac(%rip), %rbx     # 0x286c8
movq (%rbx), %rdi
xorl %esi, %esi
movl %r14d, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x4600
movq (%rbx), %rdi
callq 0x4660
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: center_pointer
void center_pointer(xcb_rectangle_t r)
{
	if (grabbing) {
		return;
	}
	int16_t cx = r.x + r.width / 2;
	int16_t cy = r.y + r.height / 2;
	xcb_warp_pointer(dpy, XCB_NONE, root, 0, 0, 0, 0, cx, cy);
}

// Assembly:
leaq 0x187d7(%rip), %rax     # 0x28e26
cmpb $0x0, (%rax)
jne 0x106ad
subq $0x18, %rsp
movq %rdi, %rcx
shrq $0x21, %rcx
andl $0x7fff, %ecx           # imm = 0x7FFF
addl %edi, %ecx
movl %edi, %eax
shrl $0x10, %eax
shrq $0x31, %rdi
addl %eax, %edi
leaq 0x1804f(%rip), %rax     # 0x286c8
movq (%rax), %rax
leaq 0x180f5(%rip), %rdx     # 0x28778
movl (%rdx), %edx
movswl %di, %esi
movl %esi, 0x10(%rsp)
andl $0x0, (%rsp)
movswl %cx, %ecx
movl %ecx, 0x8(%rsp)
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4440
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: get_atom
void get_atom(char *name, xcb_atom_t *atom)
{
	xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(dpy, xcb_intern_atom(dpy, 0, strlen(name), name), NULL);
	if (reply != NULL) {
		*atom = reply->atom;
	} else {
		*atom = XCB_NONE;
	}
	free(reply);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18005(%rip), %rax     # 0x286c8
movq (%rax), %r15
callq 0x4470
movzwl %ax, %edx
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x41b0
movq %r15, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x4690
testq %rax, %rax
je 0x106f3
movl 0x8(%rax), %r12d
movl %r12d, (%rbx)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/window.c
// Function: window_exists
bool window_exists(xcb_window_t win)
{
	xcb_generic_error_t *err;
	free(xcb_query_tree_reply(dpy, xcb_query_tree(dpy, win), &err));

	if (err != NULL) {
		free(err);
		return false;
	}

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %esi
leaq 0x17f82(%rip), %rax     # 0x286c8
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x4350
movq %rsp, %r14
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x45b0
movq %rax, %rdi
callq 0x4460
movq (%r14), %rdi
testq %rdi, %rdi
sete %bl
callq 0x4460
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/messages.c
// Function: handle_message
void handle_message(char *msg, int msg_len, FILE *rsp)
{
	int cap = INIT_CAP;
	int num = 0;
	char **args = calloc(cap, sizeof(char *));

	if (args == NULL) {
		perror("Handle message: calloc");
		return;
	}

	for (int i = 0, j = 0; i < msg_len; i++) {
		if (msg[i] == 0) {
			args[num++] = msg + j;
			j = i + 1;
		}
		if (num >= cap) {
			cap *= 2;
			char **new = realloc(args, cap * sizeof(char *));
			if (new == NULL) {
				free(args);
				perror("Handle message: realloc");
				return;
			} else {
				args = new;
			}
		}
	}

	if (num < 1) {
		free(args);
		fail(rsp, "No arguments given.\n");
		return;
	}

	char **args_orig = args;
	process_message(args, num, rsp);
	free(args_orig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
pushq $0x8
popq %rdi
movq %rdi, %rsi
callq 0x48b0
testq %rax, %rax
je 0x1086c
movq %rax, %r12
movq %rbx, 0x10(%rsp)
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
pushq $0x8
popq %rbx
movl $0x0, 0xc(%rsp)
xorl %ebp, %ebp
cmpq %r13, %r14
je 0x1081a
cmpb $0x0, (%r15,%r13)
jne 0x107f3
movslq 0xc(%rsp), %rax
addq %r15, %rax
movslq %ebp, %rcx
incl %ebp
movq %rax, (%r12,%rcx,8)
leal 0x1(%r13), %eax
movl %eax, 0xc(%rsp)
cmpl %ebx, %ebp
jge 0x107fc
movq %r12, %rax
jmp 0x10812
addl %ebx, %ebx
movslq %ebx, %rsi
shlq $0x3, %rsi
movq %r12, %rdi
callq 0x49f0
testq %rax, %rax
je 0x10875
incq %r13
movq %rax, %r12
jmp 0x107ce
testl %ebp, %ebp
jle 0x10843
movq %r12, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
callq 0x1093c
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4460
movq %r12, %rdi
callq 0x4460
leaq 0xe3ed(%rip), %rsi      # 0x1ec3f
movq 0x10(%rsp), %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10897
leaq 0xe39d(%rip), %rdi      # 0x1ec10
jmp 0x10884
movq %r12, %rdi
callq 0x4460
leaq 0xe3a3(%rip), %rdi      # 0x1ec27
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a10
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/messages.c
// Function: process_message
void process_message(char **args, int num, FILE *rsp)
{
	if (streq("node", *args)) {
		cmd_node(++args, --num, rsp);
	} else if (streq("desktop", *args)) {
		cmd_desktop(++args, --num, rsp);
	} else if (streq("monitor", *args)) {
		cmd_monitor(++args, --num, rsp);
	} else if (streq("query", *args)) {
		cmd_query(++args, --num, rsp);
	} else if (streq("subscribe", *args)) {
		cmd_subscribe(++args, --num, rsp);
		return;
	} else if (streq("wm", *args)) {
		cmd_wm(++args, --num, rsp);
	} else if (streq("rule", *args)) {
		cmd_rule(++args, --num, rsp);
	} else if (streq("config", *args)) {
		cmd_config(++args, --num, rsp);
	} else if (streq("quit", *args)) {
		cmd_quit(++args, --num, rsp);
	} else {
		fail(rsp, "Unknown domain or command: '%s'.\n", *args);
	}

	fflush(rsp);
	fclose(rsp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %r15
leaq 0xe8a7(%rip), %rdi      # 0x1f1fc
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10a41
leaq 0xe87d(%rip), %rdi      # 0x1f1e9
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10a59
leaq 0xe853(%rip), %rdi      # 0x1f1d6
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10a71
leaq 0xe2ba(%rip), %rdi      # 0x1ec54
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10a89
leaq 0xe2a9(%rip), %rdi      # 0x1ec5a
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10a9e
movzbl (%r15), %eax
subl $0x77, %eax
jne 0x109d9
movzbl 0x1(%r15), %eax
subl $0x6d, %eax
jne 0x109d9
movzbl 0x2(%r15), %eax
negl %eax
testl %eax, %eax
je 0x10abb
leaq 0xe27a(%rip), %rdi      # 0x1ec64
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10ad0
leaq 0xd64a(%rip), %rdi      # 0x1e04b
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10ae5
leaq 0xe251(%rip), %rdi      # 0x1ec69
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x10afa
leaq 0xe23f(%rip), %rsi      # 0x1ec6e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10897
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x10b27
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x11e94
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1255f
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12b29
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13439
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1366d
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13a41
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13dcd
jmp 0x10b0d
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14008
movq %rbx, %rdi
callq 0x4af0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x48c0
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/messages.c
// Function: cmd_quit
void cmd_quit(char **args, int num, FILE *rsp)
{
	if (num > 0 && sscanf(*args, "%i", &exit_status) != 1) {
		fail(rsp, "%s: Invalid argument: '%s'.\n", *(args - 1), *args);
		return;
	}
	running = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x14033
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xc0ff(%rip), %rsi      # 0x2011f
leaq 0x146c9(%rip), %rdx     # 0x286f0
xorl %eax, %eax
callq 0x41c0
cmpl $0x1, %eax
jne 0x14045
leaq 0x14696(%rip), %rax     # 0x286d0
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq -0x8(%r14), %rdx
movq (%r14), %rcx
leaq 0xb431(%rip), %rsi      # 0x1f484
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10897
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/messages.c
// Function: handle_failure
void handle_failure(int code, char *src, char *val, FILE *rsp)
{
	switch (code) {
		case SELECTOR_BAD_DESCRIPTOR:
			fail(rsp, "%s: Invalid descriptor found in '%s'.\n", src, val);
			break;
		case SELECTOR_BAD_MODIFIERS:
			fail(rsp, "%s: Invalid modifier found in '%s'.\n", src, val);
			break;
		case SELECTOR_INVALID:
			fail(rsp, "");
			break;
	}
}

// Assembly:
cmpl $0x1, %edi
je 0x14096
movq %rdx, %rax
movq %rsi, %rdx
cmpl $0x2, %edi
je 0x14082
cmpl $0x3, %edi
jne 0x140a7
leaq 0xb917(%rip), %rsi      # 0x1f997
jmp 0x14089
leaq 0xb935(%rip), %rsi      # 0x1f9be
movq %rcx, %rdi
movq %rax, %rcx
xorl %eax, %eax
jmp 0x10897
leaq 0xc4bb(%rip), %rsi      # 0x20558
movq %rcx, %rdi
xorl %eax, %eax
jmp 0x10897
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_bool
bool parse_bool(char *value, bool *b)
{
	if (streq("true", value) || streq("on", value)) {
		*b = true;
		return true;
	} else if (streq("false", value) || streq("off", value)) {
		*b = false;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa24e(%rip), %rdi      # 0x1f987
movq %r14, %rsi
callq 0x4820
movb $0x1, %bpl
movb $0x1, %cl
testl %eax, %eax
je 0x15798
movzbl (%r14), %eax
subl $0x6f, %eax
jne 0x15762
movzbl 0x1(%r14), %eax
subl $0x6e, %eax
jne 0x15762
movzbl 0x2(%r14), %eax
negl %eax
movb $0x1, %cl
testl %eax, %eax
je 0x15798
leaq 0xa21b(%rip), %rdi      # 0x1f98c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15796
leaq 0x9116(%rip), %rdi      # 0x1e89a
movq %r14, %rsi
callq 0x4820
xorl %ecx, %ecx
testl %eax, %eax
je 0x15798
xorl %ebp, %ebp
jmp 0x1579a
xorl %ecx, %ecx
movb %cl, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_split_type
bool parse_split_type(char *s, split_type_t *t)
{
	if (streq("horizontal", s)) {
		*t = TYPE_HORIZONTAL;
		return true;
	} else if (streq("vertical", s)) {
		*t = TYPE_VERTICAL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa571(%rip), %rdi      # 0x1fd23
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x157d5
leaq 0xa56a(%rip), %rdi      # 0x1fd2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x157d9
xorl %eax, %eax
jmp 0x157e0
xorl %eax, %eax
jmp 0x157dc
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_split_mode
bool parse_split_mode(char *s, split_mode_t *m)
{
	if (streq("automatic", s)) {
		*m = MODE_AUTOMATIC;
		return true;
	} else if (streq("vertical", s)) {
		*m = MODE_MANUAL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa486(%rip), %rdi      # 0x1fc7f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1581c
leaq 0xa523(%rip), %rdi      # 0x1fd2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15820
xorl %eax, %eax
jmp 0x15827
xorl %eax, %eax
jmp 0x15823
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_client_state
bool parse_client_state(char *s, client_state_t *t)
{
	if (streq("tiled", s)) {
		*t = STATE_TILED;
		return true;
	} else if (streq("pseudo_tiled", s)) {
		*t = STATE_PSEUDO_TILED;
		return true;
	} else if (streq("floating", s)) {
		*t = STATE_FLOATING;
		return true;
	} else if (streq("fullscreen", s)) {
		*t = STATE_FULLSCREEN;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa3d0(%rip), %rdi      # 0x1fc55
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x158ce
leaq 0xa400(%rip), %rdi      # 0x1fc98
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x158d2
leaq 0xa3fb(%rip), %rdi      # 0x1fca6
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x158d6
leaq 0xa3f2(%rip), %rdi      # 0x1fcb0
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x158da
xorl %eax, %eax
jmp 0x158e1
xorl %eax, %eax
jmp 0x158dd
pushq $0x1
jmp 0x158dc
pushq $0x2
jmp 0x158dc
pushq $0x3
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_stack_layer
bool parse_stack_layer(char *s, stack_layer_t *l)
{
	if (streq("below", s)) {
		*l = LAYER_BELOW;
		return true;
	} else if (streq("normal", s)) {
		*l = LAYER_NORMAL;
		return true;
	} else if (streq("above", s)) {
		*l = LAYER_ABOVE;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa413(%rip), %rdi      # 0x1fd0d
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15930
leaq 0xa407(%rip), %rdi      # 0x1fd14
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15934
leaq 0xa3fc(%rip), %rdi      # 0x1fd1c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15938
xorl %eax, %eax
jmp 0x1593f
xorl %eax, %eax
jmp 0x1593b
pushq $0x1
jmp 0x1593a
pushq $0x2
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_direction
bool parse_direction(char *s, direction_t *d)
{
	if (streq("north", s)) {
		*d = DIR_NORTH;
		return true;
	} else if (streq("west", s)) {
		*d = DIR_WEST;
		return true;
	} else if (streq("south", s)) {
		*d = DIR_SOUTH;
		return true;
	} else if (streq("east", s)) {
		*d = DIR_EAST;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8d11(%rip), %rdi      # 0x1e669
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159a1
leaq 0xa8d6(%rip), %rdi      # 0x20241
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159a5
leaq 0x8cf1(%rip), %rdi      # 0x1e66f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159a9
leaq 0x8ce4(%rip), %rdi      # 0x1e675
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159ad
xorl %eax, %eax
jmp 0x159b4
xorl %eax, %eax
jmp 0x159b0
pushq $0x1
jmp 0x159af
pushq $0x2
jmp 0x159af
pushq $0x3
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_cycle_direction
bool parse_cycle_direction(char *s, cycle_dir_t *d)
{
	if (streq("next", s)) {
		*d = CYCLE_NEXT;
		return true;
	} else if (streq("prev", s)) {
		*d = CYCLE_PREV;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa016(%rip), %rdi      # 0x1f9e3
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159f0
leaq 0xa008(%rip), %rdi      # 0x1f9e8
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x159f4
xorl %eax, %eax
jmp 0x159fb
xorl %eax, %eax
jmp 0x159f7
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_circulate_direction
bool parse_circulate_direction(char *s, circulate_dir_t *d)
{
	if (streq("forward", s)) {
		*d = CIRCULATE_FORWARD;
		return true;
	} else if (streq("backward", s)) {
		*d = CIRCULATE_BACKWARD;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9fd9(%rip), %rdi      # 0x1f9ed
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15a37
leaq 0x9fce(%rip), %rdi      # 0x1f9f5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15a3b
xorl %eax, %eax
jmp 0x15a42
xorl %eax, %eax
jmp 0x15a3e
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_history_direction
bool parse_history_direction(char *s, history_dir_t *d)
{
	if (streq("older", s)) {
		*d = HISTORY_OLDER;
		return true;
	} else if (streq("newer", s)) {
		*d = HISTORY_NEWER;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9fa3(%rip), %rdi      # 0x1f9fe
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15a7e
leaq 0x9f96(%rip), %rdi      # 0x1fa04
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15a82
xorl %eax, %eax
jmp 0x15a89
xorl %eax, %eax
jmp 0x15a85
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_flip
bool parse_flip(char *s, flip_t *f)
{
	if (streq("horizontal", s)) {
		*f = FLIP_HORIZONTAL;
		return true;
	} else if (streq("vertical", s)) {
		*f = FLIP_VERTICAL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa281(%rip), %rdi      # 0x1fd23
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15ac5
leaq 0xa27a(%rip), %rdi      # 0x1fd2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15ac9
xorl %eax, %eax
jmp 0x15ad0
xorl %eax, %eax
jmp 0x15acc
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq