LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x19638(%rip), %rax     # 0x296c8
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 0x100e6
movq 0x8(%rsp), %rsi
leaq 0xfb1a(%rip), %rdi      # 0x1fbd6
callq 0x4820
testl %eax, %eax
je 0x100c9
xorl %ebx, %ebx
jmp 0x100de
movq (%rsp), %rsi
leaq 0xfb08(%rip), %rdi      # 0x1fbdc
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_O3/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 0x10213
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x10209
cmpl $0x0, 0xc(%rax)
jne 0x10209
leaq 0x195a4(%rip), %r14     # 0x296c8
movq (%r14), %rdi
callq 0x4920
movl %eax, %ebp
leaq 0x19b6b(%rip), %rdi     # 0x29ca0
callq 0x5c17
leaq 0x8(%rsp), %r10
movl %eax, (%r10)
movl $0x1, %eax
movl %eax, 0x4(%r10)
movq (%r14), %rdi
leaq 0x19623(%rip), %rcx     # 0x29778
movl (%rcx), %ecx
subq $0x8, %rsp
xorl %r15d, %r15d
xorl %esi, %esi
movl %ebp, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq $0x402                  # imm = 0x402
pushq %r15
pushq %rax
pushq %r15
pushq %rax
pushq %rax
callq 0x4030
addq $0x40, %rsp
movq (%r14), %rdi
leaq 0xfa37(%rip), %rcx      # 0x1fbc0
movl %ebp, %esi
movl $0x16, %edx
callq 0x4710
movq (%r14), %rdi
subq $0x8, %rsp
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq %r15
pushq %r15
callq 0x4410
addq $0x20, %rsp
leaq 0x1957f(%rip), %rax     # 0x29740
movq (%rax), %rax
testq %rax, %rax
je 0x10202
movq (%rax), %rcx
movq 0x48(%rcx), %rdx
cmpl $0x1, 0x308(%rdx)
jbe 0x101df
movq 0x8(%rax), %rax
jmp 0x101c4
movl (%rcx), %eax
testl %eax, %eax
je 0x10202
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl $0x0, 0x4(%rcx)
movq (%r14), %rdi
movl %ebp, %esi
movl $0x60, %edx
callq 0x4310
movq 0x10(%rbx), %rax
movl %ebp, 0xc(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0x1043f
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x10(%rbx)
je 0x10422
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10242
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x103fa
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x1040d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0x10486
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x10469
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x11398
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10440
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x10453
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0x104ca
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x104ad
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x11398
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10487
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x1049a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x105ee
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x10586
leaq 0x19766(%rip), %rdi     # 0x29ca0
callq 0x5c17
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x1917b(%rip), %rax     # 0x296c8
movq (%rax), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
movl $0x2, %edx
callq 0x4700
cmpq %r15, 0x58(%r14)
jne 0x10586
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x11398
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x11398
cmpq %rbx, 0x38(%r15)
je 0x105a9
cmpq $0x0, 0x48(%rbx)
je 0x105c7
leaq 0x19176(%rip), %rax     # 0x29710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x105c0
leaq 0x19160(%rip), %rax     # 0x29710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %rbx, %rdi
movl $0x1, %esi
callq 0xff61
jmp 0x105e5
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10511
movq 0x38(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10511
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19078(%rip), %rax     # 0x296c8
movq (%rax), %rbx
leaq 0x1911e(%rip), %rax     # 0x29778
movl (%rax), %esi
movq %rbx, %rdi
callq 0x4350
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x45b0
testq %rax, %rax
je 0x106e4
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a70
movl %eax, %ebp
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x47e0
testl %ebp, %ebp
jle 0x106da
movq %rax, %r14
movl %ebp, %r13d
xorl %ebx, %ebx
leaq 0x14(%rsp), %r15
movl (%r14,%rbx,4), %ebp
leaq 0x19785(%rip), %rax     # 0x29e30
movq (%rax), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x4740
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x4300
cmpb $0x1, %al
jne 0x106d2
movl %ebp, %edi
callq 0xf78c
incq %rbx
cmpq %rbx, %r13
jne 0x106a0
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_O3/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 0x10746
leaq 0x18fc0(%rip), %rax     # 0x296c8
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 0x10746
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 0x10760
leaq 0x1902f(%rip), %rax     # 0x2977c
movzwl (%rax), %ebp
leaq 0x19029(%rip), %rax     # 0x29780
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_O3/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
movl $0x0, (%rbx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x1095f
cmpl $0x0, (%rbx)
je 0x111ee
movl 0x4(%rsp), %edi
callq 0x7446
testq %rax, %rax
je 0x111ee
movq %rax, %rbx
movq 0x58(%rax), %r14
movq 0x30(%r14), %rdi
callq 0x920c
testq %rax, %rax
je 0x111a8
movl (%rsp), %edi
cmpl %edi, (%rax)
je 0x111b9
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1119a
cmpl %edi, 0xc(%rcx)
je 0x111b9
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x926e
jmp 0x11180
leaq 0x18561(%rip), %rax     # 0x29710
cmpq (%rax), %rbx
je 0x111d4
movl (%rsp), %edi
jmp 0x111cd
leaq 0x18550(%rip), %rcx     # 0x29710
movq (%rcx), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
je 0x111d4
callq 0x111f6
jmp 0x111ee
leaq 0x1850d(%rip), %rbx     # 0x296e8
cmpb $0x1, 0x6(%rbx)
jne 0x111ee
movl (%rbx), %edi
xorl %esi, %esi
callq 0x11398
movb $0x0, 0x6(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
leaq 0x184bf(%rip), %r14     # 0x296c8
movq (%r14), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45c0
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x46a0
movq %rax, %rbx
testq %rax, %rax
je 0x112a7
movl 0x14(%rbx), %eax
addl %eax, %eax
leaq 0x184b2(%rip), %r15     # 0x296e8
movl (%r15), %esi
movswl 0xc(%rbx), %edx
movswl 0xe(%rbx), %edi
movq %rsp, %rcx
movl %edx, (%rcx)
movl %edi, 0x4(%rcx)
movd 0x10(%rbx), %xmm0
movd %eax, %xmm1
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
paddw %xmm0, %xmm1
pxor %xmm0, %xmm0
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
movq %xmm1, 0x8(%rcx)
movq (%r14), %rdi
movl $0xf, %edx
callq 0x4310
testl %ebp, %ebp
je 0x11295
movl (%r15), %esi
movq %rsp, %rcx
movl %ebp, (%rcx)
movl $0x0, 0x4(%rcx)
movq (%r14), %rdi
movl $0x60, %edx
callq 0x4310
movl (%r15), %edi
movl $0x1, %esi
callq 0x11398
movb $0x1, 0x6(%r15)
movq %rbx, %rdi
callq 0x4460
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/window.c
// Function: disable_motion_recorder
void disable_motion_recorder(void)
{
	if (!motion_recorder.enabled) {
		return;
	}
	window_hide(motion_recorder.id);
	motion_recorder.enabled = false;
}

// Assembly:
pushq %rbx
leaq 0x18426(%rip), %rbx     # 0x296e8
cmpb $0x1, 0x6(%rbx)
jne 0x112d5
movl (%rbx), %edi
xorl %esi, %esi
callq 0x11398
movb $0x0, 0x6(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0xc(%rsp), %rcx
movl $0x320004, (%rcx)       # imm = 0x320004
movl $0x3a0004, 0x8(%rsp)    # imm = 0x3A0004
leaq 0x18308(%rip), %r14     # 0x296c8
movq (%r14), %rdi
leaq 0x183ae(%rip), %r15     # 0x29778
movl (%r15), %esi
movl $0x800, %edx            # imm = 0x800
callq 0x4700
testl %ebp, %ebp
je 0x11420
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %rdi
leaq 0x1838b(%rip), %rcx     # 0x29784
movl (%rcx), %ecx
xorl %esi, %esi
movl %ebx, %edx
movl %ecx, %r8d
movl $0x20, %r9d
pushq %rax
pushq $0x2
callq 0x48e0
addq $0x10, %rsp
movq (%r14), %rdi
movl %ebx, %esi
callq 0x43e0
jmp 0x11463
movq (%r14), %rdi
movl %ebx, %esi
callq 0x4930
leaq 0x10(%rsp), %rax
movq $0x3, (%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %rdi
leaq 0x1833c(%rip), %rcx     # 0x29784
movl (%rcx), %ecx
xorl %esi, %esi
movl %ebx, %edx
movl %ecx, %r8d
movl $0x20, %r9d
pushq %rax
pushq $0x2
callq 0x48e0
addq $0x10, %rsp
movq (%r14), %rdi
movl (%r15), %esi
leaq 0x8(%rsp), %rcx
movl $0x800, %edx            # imm = 0x800
callq 0x4700
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x114c7
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x114c7
cmpb $0x1, 0x375(%rax)
jne 0x114e6
leaq 0x18210(%rip), %rax     # 0x296c8
movq (%rax), %rax
movl (%rdi), %edx
movq %rax, %rdi
movl $0x2, %esi
jmp 0x114df
leaq 0x181fa(%rip), %rax     # 0x296c8
movq (%rax), %rdi
leaq 0x182a0(%rip), %rax     # 0x29778
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
jmp 0x4200
cmpb $0x1, 0x374(%rax)
jne 0x1150f
movl (%rdi), %edi
leaq 0x18938(%rip), %rax     # 0x29e30
movq (%rax), %rax
movl 0xc8(%rax), %esi
leaq 0x18284(%rip), %rax     # 0x2978c
movl (%rax), %edx
jmp 0x1152f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1888e(%rip), %rax     # 0x29e26
cmpb $0x0, (%rax)
jne 0x115f4
pushq %rax
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 0x18109(%rip), %rax     # 0x296c8
movq (%rax), %rax
leaq 0x181af(%rip), %rdx     # 0x29778
movl (%rdx), %edx
movswl %di, %r10d
subq $0x8, %rsp
movswl %cx, %r11d
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
pushq $0x0
callq 0x4440
addq $0x20, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18035(%rip), %rax     # 0x296c8
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), %rbx
testq %rbx, %rbx
je 0x116c6
movq %rbx, %rdi
callq 0x4460
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movq %rdi, %r14
movl $0x8, %edi
movl $0x8, %esi
callq 0x48b0
testq %rax, %rax
je 0x117d2
movq %rax, %r15
testl %ebp, %ebp
jle 0x117ab
movq %rbx, 0x10(%rsp)
movl %ebp, %edx
xorl %ebx, %ebx
movl $0x8, %r13d
xorl %ebp, %ebp
movl $0x0, 0xc(%rsp)
cmpb $0x0, (%r14,%rbx)
jne 0x11745
movslq 0xc(%rsp), %rax
addq %r14, %rax
movslq %ebp, %rcx
incl %ebp
movq %rax, (%r15,%rcx,8)
leal 0x1(%rbx), %eax
movl %eax, 0xc(%rsp)
cmpl %r13d, %ebp
jge 0x1174f
movq %r15, %r12
jmp 0x1176f
addl %r13d, %r13d
movslq %r13d, %rsi
shlq $0x3, %rsi
movq %r15, %rdi
movq %rdx, %r12
callq 0x49f0
movq %r12, %rdx
movq %rax, %r12
testq %rax, %rax
je 0x117db
incq %rbx
movq %r12, %r15
cmpq %rbx, %rdx
jne 0x11726
testl %ebp, %ebp
jle 0x117a3
movq %r12, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
callq 0x118a4
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4460
movq %r12, %r15
movq 0x10(%rsp), %rbx
movq %r15, %rdi
callq 0x4460
leaq 0xe485(%rip), %rsi      # 0x1fc3f
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x117fd
leaq 0xe437(%rip), %rdi      # 0x1fc10
jmp 0x117ea
movq %r15, %rdi
callq 0x4460
leaq 0xe43d(%rip), %rdi      # 0x1fc27
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a10
// File: /workspace/github_c_makefile_star2_O3/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 0xe93f(%rip), %rdi      # 0x201fc
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x119a9
leaq 0xe915(%rip), %rdi      # 0x201e9
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x119c1
leaq 0xe8eb(%rip), %rdi      # 0x201d6
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x119d9
leaq 0xe352(%rip), %rdi      # 0x1fc54
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x119f1
leaq 0xe341(%rip), %rdi      # 0x1fc5a
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a06
movzbl (%r15), %eax
subl $0x77, %eax
jne 0x11941
movzbl 0x1(%r15), %eax
subl $0x6d, %eax
jne 0x11941
movzbl 0x2(%r15), %eax
negl %eax
testl %eax, %eax
je 0x11a23
leaq 0xe312(%rip), %rdi      # 0x1fc64
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a38
leaq 0xd6e2(%rip), %rdi      # 0x1f04b
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a4d
leaq 0xe2e9(%rip), %rdi      # 0x1fc69
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a62
leaq 0xe2d7(%rip), %rsi      # 0x1fc6e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x117fd
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x11a8f
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12e62
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13542
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13b8d
jmp 0x11a75
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 0x14507
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14748
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14b2f
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14f20
jmp 0x11a75
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x15174
movq %rbx, %rdi
callq 0x4b00
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x48c0
// File: /workspace/github_c_makefile_star2_O3/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 0x1519f
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xbf93(%rip), %rsi      # 0x2111f
leaq 0x1455d(%rip), %rdx     # 0x296f0
xorl %eax, %eax
callq 0x41c0
cmpl $0x1, %eax
jne 0x151b1
leaq 0x1452a(%rip), %rax     # 0x296d0
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq -0x8(%r14), %rdx
movq (%r14), %rcx
leaq 0xb2c5(%rip), %rsi      # 0x20484
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x117fd
// File: /workspace/github_c_makefile_star2_O3/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 0x15202
movq %rdx, %rax
movq %rsi, %rdx
cmpl $0x2, %edi
je 0x151ee
cmpl $0x3, %edi
jne 0x15213
leaq 0xb7ab(%rip), %rsi      # 0x20997
jmp 0x151f5
leaq 0xb7c9(%rip), %rsi      # 0x209be
movq %rcx, %rdi
movq %rax, %rcx
xorl %eax, %eax
jmp 0x117fd
leaq 0xc34f(%rip), %rsi      # 0x21558
movq %rcx, %rdi
xorl %eax, %eax
jmp 0x117fd
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa0f2(%rip), %rdi      # 0x20987
movq %r14, %rsi
callq 0x4820
movb $0x1, %bpl
movb $0x1, %cl
testl %eax, %eax
je 0x168f4
movzbl (%r14), %eax
subl $0x6f, %eax
jne 0x168be
movzbl 0x1(%r14), %eax
subl $0x6e, %eax
jne 0x168be
movzbl 0x2(%r14), %eax
negl %eax
movb $0x1, %cl
testl %eax, %eax
je 0x168f4
leaq 0xa0bf(%rip), %rdi      # 0x2098c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x168f2
leaq 0x8fba(%rip), %rdi      # 0x1f89a
movq %r14, %rsi
callq 0x4820
xorl %ecx, %ecx
testl %eax, %eax
je 0x168f4
xorl %ebp, %ebp
jmp 0x168f6
xorl %ecx, %ecx
movb %cl, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa415(%rip), %rdi      # 0x20d23
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16931
leaq 0xa40e(%rip), %rdi      # 0x20d2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16935
xorl %eax, %eax
jmp 0x1693e
xorl %eax, %eax
jmp 0x1693a
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa328(%rip), %rdi      # 0x20c7f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1697a
leaq 0xa3c5(%rip), %rdi      # 0x20d2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1697e
xorl %eax, %eax
jmp 0x16987
xorl %eax, %eax
jmp 0x16983
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa26e(%rip), %rdi      # 0x20c55
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a30
leaq 0xa29e(%rip), %rdi      # 0x20c98
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a34
leaq 0xa299(%rip), %rdi      # 0x20ca6
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a3b
leaq 0xa290(%rip), %rdi      # 0x20cb0
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a42
xorl %eax, %eax
jmp 0x16a4b
xorl %eax, %eax
jmp 0x16a47
movl $0x1, %eax
jmp 0x16a47
movl $0x2, %eax
jmp 0x16a47
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa2a9(%rip), %rdi      # 0x20d0d
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a9a
leaq 0xa29d(%rip), %rdi      # 0x20d14
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a9e
leaq 0xa292(%rip), %rdi      # 0x20d1c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16aa5
xorl %eax, %eax
jmp 0x16aae
xorl %eax, %eax
jmp 0x16aaa
movl $0x1, %eax
jmp 0x16aaa
movl $0x2, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8ba2(%rip), %rdi      # 0x1f669
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b10
leaq 0xa767(%rip), %rdi      # 0x21241
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b14
leaq 0x8b82(%rip), %rdi      # 0x1f66f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b1b
leaq 0x8b75(%rip), %rdi      # 0x1f675
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b22
xorl %eax, %eax
jmp 0x16b2b
xorl %eax, %eax
jmp 0x16b27
movl $0x1, %eax
jmp 0x16b27
movl $0x2, %eax
jmp 0x16b27
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e9f(%rip), %rdi      # 0x209e3
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b67
leaq 0x9e91(%rip), %rdi      # 0x209e8
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b6b
xorl %eax, %eax
jmp 0x16b74
xorl %eax, %eax
jmp 0x16b70
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e60(%rip), %rdi      # 0x209ed
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bb0
leaq 0x9e55(%rip), %rdi      # 0x209f5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bb4
xorl %eax, %eax
jmp 0x16bbd
xorl %eax, %eax
jmp 0x16bb9
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e28(%rip), %rdi      # 0x209fe
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bf9
leaq 0x9e1b(%rip), %rdi      # 0x20a04
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bfd
xorl %eax, %eax
jmp 0x16c06
xorl %eax, %eax
jmp 0x16c02
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa104(%rip), %rdi      # 0x20d23
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c42
leaq 0xa0fd(%rip), %rdi      # 0x20d2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c46
xorl %eax, %eax
jmp 0x16c4f
xorl %eax, %eax
jmp 0x16c4b
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_resize_handle
bool parse_resize_handle(char *s, resize_handle_t *h)
{
	if (streq("left", s)) {
		*h = HANDLE_LEFT;
		return true;
	} else if (streq("top", s)) {
		*h = HANDLE_TOP;
		return true;
	} else if (streq("right", s)) {
		*h = HANDLE_RIGHT;
		return true;
	} else if (streq("bottom", s)) {
		*h = HANDLE_BOTTOM;
		return true;
	} else if (streq("top_left", s)) {
		*h = HANDLE_TOP_LEFT;
		return true;
	} else if (streq("top_right", s)) {
		*h = HANDLE_TOP_RIGHT;
		return true;
	} else if (streq("bottom_right", s)) {
		*h = HANDLE_BOTTOM_RIGHT;
		return true;
	} else if (streq("bottom_left", s)) {
		*h = HANDLE_BOTTOM_LEFT;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9dd0(%rip), %rdi      # 0x20a38
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d01
leaq 0x88d8(%rip), %rdi      # 0x1f557
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d08
leaq 0x9d99(%rip), %rdi      # 0x20a2b
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d0f
leaq 0x9d65(%rip), %rdi      # 0x20a0a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d16
leaq 0x9d59(%rip), %rdi      # 0x20a11
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d1d
leaq 0x9d4f(%rip), %rdi      # 0x20a1a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d24
leaq 0x9d46(%rip), %rdi      # 0x20a24
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d2b
leaq 0x9d40(%rip), %rdi      # 0x20a31
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d32
xorl %eax, %eax
jmp 0x16d3b
movl $0x1, %eax
jmp 0x16d37
movl $0x2, %eax
jmp 0x16d37
movl $0x4, %eax
jmp 0x16d37
movl $0x8, %eax
jmp 0x16d37
movl $0x3, %eax
jmp 0x16d37
movl $0x6, %eax
jmp 0x16d37
movl $0xc, %eax
jmp 0x16d37
movl $0x9, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_modifier_mask
bool parse_modifier_mask(char *s, uint16_t *m)
{
	if (strcmp(s, "shift") == 0) {
		*m = XCB_MOD_MASK_SHIFT;
		return true;
	} else if (strcmp(s, "control") == 0) {
		*m = XCB_MOD_MASK_CONTROL;
		return true;
	} else if (strcmp(s, "lock") == 0) {
		*m = XCB_MOD_MASK_LOCK;
		return true;
	} else if (strcmp(s, "mod1") == 0) {
		*m = XCB_MOD_MASK_1;
		return true;
	} else if (strcmp(s, "mod2") == 0) {
		*m = XCB_MOD_MASK_2;
		return true;
	} else if (strcmp(s, "mod3") == 0) {
		*m = XCB_MOD_MASK_3;
		return true;
	} else if (strcmp(s, "mod4") == 0) {
		*m = XCB_MOD_MASK_4;
		return true;
	} else if (strcmp(s, "mod5") == 0) {
		*m = XCB_MOD_MASK_5;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9ce9(%rip), %rsi      # 0x20a3d
callq 0x4820
testl %eax, %eax
je 0x16dea
leaq 0x9cdb(%rip), %rsi      # 0x20a43
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16df0
leaq 0x9cd0(%rip), %rsi      # 0x20a4b
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16df6
leaq 0x9cc2(%rip), %rsi      # 0x20a50
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16dfc
leaq 0x9cb4(%rip), %rsi      # 0x20a55
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e02
leaq 0x9ca6(%rip), %rsi      # 0x20a5a
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e08
leaq 0x9c98(%rip), %rsi      # 0x20a5f
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e0e
leaq 0x9c8a(%rip), %rsi      # 0x20a64
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e14
xorl %eax, %eax
jmp 0x16e1d
movw $0x1, %ax
jmp 0x16e18
movw $0x4, %ax
jmp 0x16e18
movw $0x2, %ax
jmp 0x16e18
movw $0x8, %ax
jmp 0x16e18
movw $0x10, %ax
jmp 0x16e18
movw $0x20, %ax
jmp 0x16e18
movw $0x40, %ax
jmp 0x16e18
movw $0x80, %ax
movw %ax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_button_index
bool parse_button_index(char *s, int8_t *b)
{
	if (strcmp(s, "any") == 0) {
		*b = XCB_BUTTON_INDEX_ANY;
		return true;
	} else if (strcmp(s, "button1") == 0) {
		*b = XCB_BUTTON_INDEX_1;
		return true;
	} else if (strcmp(s, "button2") == 0) {
		*b = XCB_BUTTON_INDEX_2;
		return true;
	} else if (strcmp(s, "button3") == 0) {
		*b = XCB_BUTTON_INDEX_3;
		return true;
	} else if (strcmp(s, "none") == 0) {
		*b = -1;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9c33(%rip), %rsi      # 0x20a69
callq 0x4820
testl %eax, %eax
je 0x16e8f
leaq 0x9c27(%rip), %rsi      # 0x20a6d
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e93
leaq 0x9c1c(%rip), %rsi      # 0x20a75
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e97
leaq 0x9c11(%rip), %rsi      # 0x20a7d
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e9b
leaq 0x9c06(%rip), %rsi      # 0x20a85
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16e9f
xorl %eax, %eax
jmp 0x16ea5
xorl %eax, %eax
jmp 0x16ea1
movb $0x1, %al
jmp 0x16ea1
movb $0x2, %al
jmp 0x16ea1
movb $0x3, %al
jmp 0x16ea1
movb $-0x1, %al
movb %al, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_pointer_action
bool parse_pointer_action(char *s, pointer_action_t *a)
{
	if (streq("move", s)) {
		*a = ACTION_MOVE;
		return true;
	} else if (streq("resize_corner", s)) {
		*a = ACTION_RESIZE_CORNER;
		return true;
	} else if (streq("resize_side", s)) {
		*a = ACTION_RESIZE_SIDE;
		return true;
	} else if (streq("focus", s)) {
		*a = ACTION_FOCUS;
		return true;
	} else if (streq("none", s)) {
		*a = ACTION_NONE;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8f69(%rip), %rdi      # 0x1fe27
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f1c
leaq 0x9bb9(%rip), %rdi      # 0x20a8a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f23
leaq 0x9bb4(%rip), %rdi      # 0x20a98
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f2a
leaq 0x8dce(%rip), %rdi      # 0x1fcc5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f31
leaq 0x9b7b(%rip), %rdi      # 0x20a85
movq %r14, %rsi
callq 0x4820
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x16f3a
jmp 0x16f36
movl $0x2, %eax
jmp 0x16f36
movl $0x4, %eax
jmp 0x16f36
movl $0x3, %eax
jmp 0x16f36
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_child_polarity
bool parse_child_polarity(char *s, child_polarity_t *p)
{
	if (streq("first_child", s)) {
		*p = FIRST_CHILD;
		return true;
	} else if (streq("second_child", s)) {
		*p = SECOND_CHILD;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x99fd(%rip), %rdi      # 0x20950
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f76
leaq 0x99f6(%rip), %rdi      # 0x2095c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16f7a
xorl %eax, %eax
jmp 0x16f83
xorl %eax, %eax
jmp 0x16f7f
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_automatic_scheme
bool parse_automatic_scheme(char *s, automatic_scheme_t *a)
{
	if (streq("longest_side", s)) {
		*a = SCHEME_LONGEST_SIDE;
		return true;
	} else if (streq("alternate", s)) {
		*a = SCHEME_ALTERNATE;
		return true;
	} else if (streq("spiral", s)) {
		*a = SCHEME_SPIRAL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x99cd(%rip), %rdi      # 0x20969
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16fd2
leaq 0x99c7(%rip), %rdi      # 0x20976
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16fd6
leaq 0x99be(%rip), %rdi      # 0x20980
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16fdd
xorl %eax, %eax
jmp 0x16fe6
xorl %eax, %eax
jmp 0x16fe2
movl $0x1, %eax
jmp 0x16fe2
movl $0x2, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_honor_size_hints_mode
bool parse_honor_size_hints_mode(char *s, honor_size_hints_mode_t *a)
{
	bool b;
	if (parse_bool(s, &b)) {
		*a = b ? HONOR_SIZE_HINTS_YES : HONOR_SIZE_HINTS_NO;
		return true;
	} else if (streq("floating", s)) {
		*a = HONOR_SIZE_HINTS_FLOATING;
		return true;
	} else if (streq("tiled", s)) {
		*a = HONOR_SIZE_HINTS_TILED;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %rsi
callq 0x16884
testb %al, %al
je 0x1700d
movzbl 0x7(%rsp), %eax
jmp 0x17043
leaq 0x9c92(%rip), %rdi      # 0x20ca6
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17037
leaq 0x9c2e(%rip), %rdi      # 0x20c55
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1703e
xorl %eax, %eax
jmp 0x17047
movl $0x2, %eax
jmp 0x17043
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_state_transition
bool parse_state_transition(char *s, state_transition_t *m)
{
	if (streq("none", s)) {
		*m = 0;
		return true;
	} else if (streq("all", s)) {
		*m = STATE_TRANSITION_ENTER | STATE_TRANSITION_EXIT;
		return true;
	} else {
		state_transition_t w = 0;
		char *x = copy_string(s, strlen(s));
		char *key = strtok(x, ",");
		while (key != NULL) {
			if (streq("enter", key)) {
				w |= STATE_TRANSITION_ENTER;
			} else if (streq("exit", key)) {
				w |= STATE_TRANSITION_EXIT;
			} else {
				free(x);
				return false;
			}
			key = strtok(NULL, ",");
		}
		free(x);
		if (w != 0) {
			*m = w;
			return true;
		} else {
			return false;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9a1e(%rip), %rdi      # 0x20a85
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17124
leaq 0x9a26(%rip), %rdi      # 0x20aa4
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1712c
movq %r14, %rdi
callq 0x4470
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e2f
movq %rax, %r14
leaq 0x9f3f(%rip), %rsi      # 0x20fea
movq %rax, %rdi
callq 0x4850
testq %rax, %rax
je 0x17136
movq %rax, %rbp
movq %r14, (%rsp)
xorl %r14d, %r14d
leaq 0xa4b9(%rip), %r15      # 0x21582
leaq 0x9f1a(%rip), %r12      # 0x20fea
leaq 0xa076(%rip), %r13      # 0x2114d
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4820
testl %eax, %eax
je 0x170fc
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4820
movl $0x2, %ecx
testl %eax, %eax
je 0x17101
jmp 0x1713b
movl $0x1, %ecx
orl %ecx, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4850
movq %rax, %rbp
testq %rax, %rax
jne 0x170d7
movq (%rsp), %rdi
callq 0x4460
movl %r14d, (%rbx)
jmp 0x17132
movl $0x0, (%rbx)
jmp 0x17132
movl $0x3, (%rbx)
movb $0x1, %al
jmp 0x17146
movq %r14, %rdi
jmp 0x1713f
movq (%rsp), %rdi
callq 0x4460
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_degree
bool parse_degree(char *s, int *d)
{
	int i = atoi(s);
	while (i < 0)
		i += 360;
	while (i > 359)
		i -= 360;
	if ((i % 90) != 0) {
		return false;
	} else {
		*d = i;
		return true;
	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x46b0
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %eax, %edx
shrl $0x1f, %edx
subl %eax, %ecx
subl %edx, %ecx
shrl $0x3, %ecx
imulq $0x16c16c17, %rcx, %rcx # imm = 0x16C16C17
shrq $0x22, %rcx
addl %edx, %ecx
imull $0x168, %ecx, %ecx      # imm = 0x168
addl %eax, %ecx
cmpl $0x168, %ecx            # imm = 0x168
movl $0x167, %edx            # imm = 0x167
cmovael %ecx, %edx
movl %edx, %eax
shrl $0x3, %eax
imulq $0x16c16c17, %rax, %rax # imm = 0x16C16C17
shrq $0x22, %rax
imull $0x168, %eax, %esi      # imm = 0x168
movl %edx, %eax
subl %esi, %eax
subl %edx, %eax
addl %ecx, %eax
movzwl %ax, %ecx
imull $0x2d83, %ecx, %edx     # imm = 0x2D83
shrl $0x14, %edx
imull $0x5a, %edx, %edx
subw %dx, %cx
jne 0x1720f
movl %eax, (%rbx)
testw %cx, %cx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_id
bool parse_id(char *s, uint32_t *id)
{
	char *end;
	errno = 0;
	uint32_t v = strtol(s, &end, 0);
	if (errno != 0 || *end != '\0') {
		return false;
	}
	*id = v;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x47a0
movq %rax, %r15
movl $0x0, (%rax)
movq %rsp, %rsi
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x4680
cmpl $0x0, (%r15)
jne 0x17259
movq (%rsp), %rcx
cmpb $0x0, (%rcx)
je 0x17254
xorl %ebp, %ebp
jmp 0x17259
movl %eax, (%rbx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/parse.c
// Function: parse_bool_declaration
bool parse_bool_declaration(char *s, char **key, bool *value, alter_state_t *state)
{
	*key = strtok(s, EQL_TOK);
	char *v = strtok(NULL, EQL_TOK);
	if (v == NULL) {
		*state = ALTER_TOGGLE;
		return true;
	} else {
		if (parse_bool(v, value)) {
			*state = ALTER_SET;
			return true;
		} else {
			return false;
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8b15(%rip), %r12      # 0x1fd93
movq %r12, %rsi
callq 0x4850
movq %rax, (%r15)
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4850
testq %rax, %rax
je 0x172b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16884
movl $0x1, %r15d
testb %al, %al
je 0x172b7
movl %r15d, (%rbx)
movb $0x1, %al
jmp 0x172b9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq