LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1b0a3
testb %al, %al
je 0xffe9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x20(%rax), %edx
movl 0x20(%rcx), %ecx
leaq 0xf7c8(%rip), %rsi      # 0x1f77d
movl $0x10000, %edi          # imm = 0x10000
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1eb0b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb8db
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8a5c
jmp 0x10008
leaq 0x196e8(%rip), %rax     # 0x296d8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x10008
cmpl %ebx, 0x4(%rdi)
je 0x10003
movq 0x28(%rdi), %rdi
jmp 0xfff3
callq 0x1d030
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x196aa(%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 0x10074
movq 0x8(%rsp), %rsi
leaq 0xfb94(%rip), %rdi      # 0x1fbde
callq 0x4820
testl %eax, %eax
je 0x10057
xorl %ebx, %ebx
jmp 0x1006c
movq (%rsp), %rsi
leaq 0xfb82(%rip), %rdi      # 0x1fbe4
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_O1/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 0x101a1
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x10197
cmpl $0x0, 0xc(%rax)
jne 0x10197
leaq 0x19616(%rip), %r14     # 0x296c8
movq (%r14), %rdi
callq 0x4920
movl %eax, %ebp
leaq 0x19bdd(%rip), %rdi     # 0x29ca0
callq 0x5c21
leaq 0x8(%rsp), %r10
movl %eax, (%r10)
movl $0x1, %eax
movl %eax, 0x4(%r10)
movq (%r14), %rdi
leaq 0x19695(%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 0xfab1(%rip), %rcx      # 0x1fbc8
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 0x195f1(%rip), %rax     # 0x29740
movq (%rax), %rax
testq %rax, %rax
je 0x10190
movq (%rax), %rcx
movq 0x48(%rcx), %rdx
cmpl $0x1, 0x308(%rdx)
jbe 0x1016d
movq 0x8(%rax), %rax
jmp 0x10152
movl (%rcx), %eax
testl %eax, %eax
je 0x10190
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_O1/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 0x103bc
cmpq $0x0, 0x10(%rbx)
je 0x103a7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x101d0
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1037f
movq 0x38(%rbx), %rbx
jmp 0x1038d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10400
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x103eb
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x1138c
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x103c2
movq 0x38(%rbx), %rbx
jmp 0x103d0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10441
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1042c
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x1138c
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10406
movq 0x38(%rbx), %rbx
jmp 0x10414
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1056a
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x10502
leaq 0x197ea(%rip), %rdi     # 0x29ca0
callq 0x5c21
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x191ff(%rip), %rax     # 0x296c8
movq (%rax), %rdi
movq 0x10(%rbx), %rax
movl 0xc(%rax), %esi
movl $0x2, %edx
callq 0x4700
cmpq %r15, 0x58(%r14)
jne 0x10502
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
xorl %esi, %esi
callq 0x1138c
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x1138c
cmpq %rbx, 0x38(%r15)
je 0x10525
cmpq $0x0, 0x48(%rbx)
je 0x10543
leaq 0x191fa(%rip), %rax     # 0x29710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1053c
leaq 0x191e4(%rip), %rax     # 0x29710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %rbx, %rdi
movl $0x1, %esi
callq 0xff0c
jmp 0x10561
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1048d
movq 0x38(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1048d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x190fc(%rip), %rax     # 0x296c8
movq (%rax), %rbx
leaq 0x191a2(%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 0x10660
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a70
movl %eax, %ebp
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x47e0
testl %ebp, %ebp
jle 0x10656
movq %rax, %r14
movl %ebp, %r13d
xorl %ebx, %ebx
leaq 0x14(%rsp), %r15
movl (%r14,%rbx,4), %ebp
leaq 0x19809(%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 0x1064e
movl %ebp, %edi
callq 0xf730
incq %rbx
cmpq %rbx, %r13
jne 0x1061c
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_O1/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 %r12
pushq %rbx
cmpq $0x0, 0x48(%rdi)
je 0x106c8
leaq 0x19043(%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
movq %rax, %rbx
testq %rax, %rax
je 0x106c3
movzwl 0xc(%rbx), %ebp
movzwl 0xe(%rbx), %r14d
movzwl 0x10(%rbx), %r15d
movzwl 0x12(%rbx), %r12d
movq %rbx, %rdi
callq 0x4460
jmp 0x106c3
testq %rbx, %rbx
jne 0x106e3
leaq 0x190ad(%rip), %rax     # 0x2977c
movzwl (%rax), %r15d
leaq 0x190a6(%rip), %rax     # 0x29780
movzwl (%rax), %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
movzwl %r12w, %eax
shlq $0x30, %rax
movzwl %r15w, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
shll $0x10, %r14d
orq %rcx, %r14
movzwl %bp, %eax
orq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10928
cmpl $0x0, (%rbx)
je 0x111e4
movl 0x4(%rsp), %edi
callq 0x752f
testq %rax, %rax
je 0x111e4
movq %rax, %rbx
movq 0x58(%rax), %r14
movq 0x30(%r14), %rdi
callq 0x92fd
testq %rax, %rax
je 0x1119a
movl (%rsp), %ecx
cmpl %ecx, (%rax)
je 0x111c8
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x1118c
cmpl %ecx, 0xc(%rdx)
je 0x111c8
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x9363
jmp 0x11172
xorl %eax, %eax
testb %al, %al
jne 0x111ac
leaq 0x18569(%rip), %rax     # 0x29710
cmpq (%rax), %rbx
jne 0x111dc
leaq 0x18535(%rip), %rbx     # 0x296e8
cmpb $0x1, 0x6(%rbx)
jne 0x111e4
movl (%rbx), %edi
xorl %esi, %esi
callq 0x1138c
movb $0x0, 0x6(%rbx)
jmp 0x111e4
leaq 0x18541(%rip), %rcx     # 0x29710
movq (%rcx), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
je 0x111ec
movl (%rsp), %edi
callq 0x111f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
jmp 0x1119c
// File: /workspace/github_c_makefile_star2_O1/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 0x184c5(%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 0x1129b
movl 0x14(%rbx), %eax
addl %eax, %eax
movzwl 0x10(%rbx), %edx
addw %ax, %dx
addw 0x12(%rbx), %ax
leaq 0x184ad(%rip), %r15     # 0x296e8
movl (%r15), %esi
movswl 0xc(%rbx), %edi
movswl 0xe(%rbx), %r8d
movq %rsp, %rcx
movl %edi, (%rcx)
movl %r8d, 0x4(%rcx)
movzwl %dx, %edx
movl %edx, 0x8(%rcx)
movzwl %ax, %eax
movl %eax, 0xc(%rcx)
movq (%r14), %rdi
movl $0xf, %edx
callq 0x4310
testl %ebp, %ebp
je 0x11289
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 0x1138c
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_O1/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 0x18432(%rip), %rbx     # 0x296e8
cmpb $0x1, 0x6(%rbx)
jne 0x112c9
movl (%rbx), %edi
xorl %esi, %esi
callq 0x1138c
movb $0x0, 0x6(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18314(%rip), %r14     # 0x296c8
movq (%r14), %rdi
leaq 0x183ba(%rip), %r15     # 0x29778
movl (%r15), %esi
movl $0x800, %edx            # imm = 0x800
callq 0x4700
testl %ebp, %ebp
je 0x11414
leaq 0x10(%rsp), %rax
movq $0x1, (%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %rdi
leaq 0x18397(%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 0x11457
movq (%r14), %rdi
movl %ebx, %esi
callq 0x4930
leaq 0x10(%rsp), %rax
movq $0x3, (%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %rdi
leaq 0x18348(%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_O1/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 0x114bb
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x114bb
cmpb $0x1, 0x375(%rax)
jne 0x114da
leaq 0x1821c(%rip), %rax     # 0x296c8
movq (%rax), %rax
movl (%rdi), %edx
movq %rax, %rdi
movl $0x2, %esi
jmp 0x114d3
leaq 0x18206(%rip), %rax     # 0x296c8
movq (%rax), %rdi
leaq 0x182ac(%rip), %rax     # 0x29778
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
jmp 0x4200
cmpb $0x1, 0x374(%rax)
jne 0x11503
movl (%rdi), %edi
leaq 0x18944(%rip), %rax     # 0x29e30
movq (%rax), %rax
movl 0xc8(%rax), %esi
leaq 0x18290(%rip), %rax     # 0x2978c
movl (%rax), %edx
jmp 0x11523
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %edi
movl $0x1, %esi
callq 0x48b0
movq %rax, %r15
movw $0x2021, (%rax)         # imm = 0x2021
movl %r14d, 0x4(%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movl $0x0, 0x10(%rax)
leaq 0x18168(%rip), %rbx     # 0x296c8
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_O1/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 0x18893(%rip), %rax     # 0x29e26
cmpb $0x0, (%rax)
jne 0x115ef
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 0x1810e(%rip), %rax     # 0x296c8
movq (%rax), %rax
leaq 0x181b4(%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_O1/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 0x180c3(%rip), %rax     # 0x296c8
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 0x11635
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_O1/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 0x1803a(%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 0x116c1
movq %rbx, %rdi
callq 0x4460
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
movl $0x8, %edi
movl $0x8, %esi
callq 0x48b0
testq %rax, %rax
je 0x11838
movq %rax, %r15
movq %rbx, 0x8(%rsp)
testl %ebp, %ebp
setg %bl
jle 0x117d2
movl %ebp, %edx
movq %rdx, %rdi
negq %rdi
xorl %esi, %esi
movl $0x8, %r14d
movl $0x1, %ebp
movl $0x0, (%rsp)
movq %r15, %r13
movq %r12, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
cmpb $0x0, -0x1(%r12,%rbp)
jne 0x1175b
movslq (%rsp), %rax
addq %r12, %rax
movslq %esi, %rcx
incl %esi
movq %rax, (%r13,%rcx,8)
movl %ebp, (%rsp)
cmpl %r14d, %esi
jge 0x11765
movq %r13, %r15
jmp 0x1179e
movl %esi, 0x4(%rsp)
addl %r14d, %r14d
movslq %r14d, %rsi
shlq $0x3, %rsi
movq %r13, %rdi
callq 0x49f0
movq %rax, %r12
movq %rax, %r15
testq %rax, %rax
je 0x117b9
testq %r12, %r12
movl 0x4(%rsp), %esi
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
je 0x117d4
cmpq %rdx, %rbp
setb %bl
leaq (%rdi,%rbp), %rax
incq %rax
incq %rbp
movq %r15, %r13
cmpq $0x1, %rax
jne 0x1173f
jmp 0x117d4
movq %r13, %rdi
callq 0x4460
leaq 0xe46f(%rip), %rdi      # 0x1fc37
callq 0x4a10
movq %r13, %r15
jmp 0x11786
xorl %esi, %esi
testb $0x1, %bl
je 0x117e8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %esi, %esi
jle 0x1180f
movq %r15, %rdi
movq 0x8(%rsp), %rdx
callq 0x118f9
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4460
movq %r15, %rdi
callq 0x4460
leaq 0xe431(%rip), %rsi      # 0x1fc4f
movq 0x8(%rsp), %rdi
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11852
leaq 0xe3e1(%rip), %rdi      # 0x1fc20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a10
// File: /workspace/github_c_makefile_star2_O1/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 0xe930(%rip), %rdi      # 0x20242
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x119f3
leaq 0xe906(%rip), %rdi      # 0x2022f
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a0b
leaq 0xe8dc(%rip), %rdi      # 0x2021c
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a23
leaq 0xe30d(%rip), %rdi      # 0x1fc64
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a3b
leaq 0xe2fc(%rip), %rdi      # 0x1fc6a
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a50
leaq 0xe25c(%rip), %rdi      # 0x1fbe1
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a6d
leaq 0xe2d8(%rip), %rdi      # 0x1fc74
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a82
leaq 0xd698(%rip), %rdi      # 0x1f04b
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11a97
leaq 0xe2af(%rip), %rdi      # 0x1fc79
movq %r15, %rsi
callq 0x4820
testl %eax, %eax
je 0x11aac
leaq 0xe29d(%rip), %rsi      # 0x1fc7e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11852
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x11ad9
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12ff0
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x136fc
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13cd5
jmp 0x11abf
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 0x145fb
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1481d
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14bf7
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x14fde
jmp 0x11abf
addq $0x8, %r14
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x15232
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_O1/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 0x1525d
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xbf21(%rip), %rsi      # 0x2116b
leaq 0x1449f(%rip), %rdx     # 0x296f0
xorl %eax, %eax
callq 0x41c0
cmpl $0x1, %eax
jne 0x1526f
leaq 0x1446c(%rip), %rax     # 0x296d0
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq -0x8(%r14), %rdx
movq (%r14), %rcx
leaq 0xb253(%rip), %rsi      # 0x204d0
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11852
// File: /workspace/github_c_makefile_star2_O1/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 0x152c0
movq %rdx, %rax
movq %rsi, %rdx
cmpl $0x2, %edi
je 0x152ac
cmpl $0x3, %edi
jne 0x152d1
leaq 0xb739(%rip), %rsi      # 0x209e3
jmp 0x152b3
leaq 0xb757(%rip), %rsi      # 0x20a0a
movq %rcx, %rdi
movq %rax, %rcx
xorl %eax, %eax
jmp 0x11852
leaq 0xc2dd(%rip), %rsi      # 0x215a4
movq %rcx, %rdi
xorl %eax, %eax
jmp 0x11852
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa006(%rip), %rdi      # 0x209d3
movq %r14, %rsi
callq 0x4820
movb $0x1, %bpl
movb $0x1, %cl
testl %eax, %eax
je 0x16a21
leaq 0xa130(%rip), %rdi      # 0x20b15
movq %r14, %rsi
callq 0x4820
movb $0x1, %cl
testl %eax, %eax
je 0x16a21
leaq 0x9fde(%rip), %rdi      # 0x209d8
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a1f
leaq 0x8e9d(%rip), %rdi      # 0x1f8aa
movq %r14, %rsi
callq 0x4820
xorl %ecx, %ecx
testl %eax, %eax
je 0x16a21
xorl %ebp, %ebp
jmp 0x16a23
xorl %ecx, %ecx
movb %cl, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa334(%rip), %rdi      # 0x20d6f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a5e
leaq 0xa32d(%rip), %rdi      # 0x20d7b
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16a62
xorl %eax, %eax
jmp 0x16a6b
xorl %eax, %eax
jmp 0x16a67
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa247(%rip), %rdi      # 0x20ccb
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16aa7
leaq 0xa2e4(%rip), %rdi      # 0x20d7b
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16aab
xorl %eax, %eax
jmp 0x16ab4
xorl %eax, %eax
jmp 0x16ab0
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa18d(%rip), %rdi      # 0x20ca1
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b5d
leaq 0xa1bd(%rip), %rdi      # 0x20ce4
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b61
leaq 0xa1b8(%rip), %rdi      # 0x20cf2
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b68
leaq 0xa1af(%rip), %rdi      # 0x20cfc
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16b6f
xorl %eax, %eax
jmp 0x16b78
xorl %eax, %eax
jmp 0x16b74
movl $0x1, %eax
jmp 0x16b74
movl $0x2, %eax
jmp 0x16b74
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa1c8(%rip), %rdi      # 0x20d59
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bc7
leaq 0xa1bc(%rip), %rdi      # 0x20d60
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bcb
leaq 0xa1b1(%rip), %rdi      # 0x20d68
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16bd2
xorl %eax, %eax
jmp 0x16bdb
xorl %eax, %eax
jmp 0x16bd7
movl $0x1, %eax
jmp 0x16bd7
movl $0x2, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8a85(%rip), %rdi      # 0x1f679
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c3d
leaq 0xa686(%rip), %rdi      # 0x2128d
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c41
leaq 0x8a65(%rip), %rdi      # 0x1f67f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c48
leaq 0x8a58(%rip), %rdi      # 0x1f685
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c4f
xorl %eax, %eax
jmp 0x16c58
xorl %eax, %eax
jmp 0x16c54
movl $0x1, %eax
jmp 0x16c54
movl $0x2, %eax
jmp 0x16c54
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9dbe(%rip), %rdi      # 0x20a2f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c94
leaq 0x9db0(%rip), %rdi      # 0x20a34
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16c98
xorl %eax, %eax
jmp 0x16ca1
xorl %eax, %eax
jmp 0x16c9d
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9d7f(%rip), %rdi      # 0x20a39
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16cdd
leaq 0x9d74(%rip), %rdi      # 0x20a41
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16ce1
xorl %eax, %eax
jmp 0x16cea
xorl %eax, %eax
jmp 0x16ce6
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9d47(%rip), %rdi      # 0x20a4a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d26
leaq 0x9d3a(%rip), %rdi      # 0x20a50
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d2a
xorl %eax, %eax
jmp 0x16d33
xorl %eax, %eax
jmp 0x16d2f
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa023(%rip), %rdi      # 0x20d6f
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d6f
leaq 0xa01c(%rip), %rdi      # 0x20d7b
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16d73
xorl %eax, %eax
jmp 0x16d7c
xorl %eax, %eax
jmp 0x16d78
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9cef(%rip), %rdi      # 0x20a84
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e2e
leaq 0x87bb(%rip), %rdi      # 0x1f567
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e35
leaq 0x9cb8(%rip), %rdi      # 0x20a77
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e3c
leaq 0x9c84(%rip), %rdi      # 0x20a56
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e43
leaq 0x9c78(%rip), %rdi      # 0x20a5d
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e4a
leaq 0x9c6e(%rip), %rdi      # 0x20a66
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e51
leaq 0x9c65(%rip), %rdi      # 0x20a70
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e58
leaq 0x9c5f(%rip), %rdi      # 0x20a7d
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x16e5f
xorl %eax, %eax
jmp 0x16e68
movl $0x1, %eax
jmp 0x16e64
movl $0x2, %eax
jmp 0x16e64
movl $0x4, %eax
jmp 0x16e64
movl $0x8, %eax
jmp 0x16e64
movl $0x3, %eax
jmp 0x16e64
movl $0x6, %eax
jmp 0x16e64
movl $0xc, %eax
jmp 0x16e64
movl $0x9, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9c08(%rip), %rsi      # 0x20a89
callq 0x4820
testl %eax, %eax
je 0x16f17
leaq 0x9bfa(%rip), %rsi      # 0x20a8f
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f1d
leaq 0x9bef(%rip), %rsi      # 0x20a97
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f23
leaq 0x9be1(%rip), %rsi      # 0x20a9c
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f29
leaq 0x9bd3(%rip), %rsi      # 0x20aa1
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f2f
leaq 0x9bc5(%rip), %rsi      # 0x20aa6
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f35
leaq 0x9bb7(%rip), %rsi      # 0x20aab
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f3b
leaq 0x9ba9(%rip), %rsi      # 0x20ab0
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16f41
xorl %eax, %eax
jmp 0x16f4a
movw $0x1, %ax
jmp 0x16f45
movw $0x4, %ax
jmp 0x16f45
movw $0x2, %ax
jmp 0x16f45
movw $0x8, %ax
jmp 0x16f45
movw $0x10, %ax
jmp 0x16f45
movw $0x20, %ax
jmp 0x16f45
movw $0x40, %ax
jmp 0x16f45
movw $0x80, %ax
movw %ax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9b52(%rip), %rsi      # 0x20ab5
callq 0x4820
testl %eax, %eax
je 0x16fbc
leaq 0x9b46(%rip), %rsi      # 0x20ab9
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16fc0
leaq 0x9b3b(%rip), %rsi      # 0x20ac1
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16fc4
leaq 0x9b30(%rip), %rsi      # 0x20ac9
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16fc8
leaq 0x9b25(%rip), %rsi      # 0x20ad1
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x16fcc
xorl %eax, %eax
jmp 0x16fd2
xorl %eax, %eax
jmp 0x16fce
movb $0x1, %al
jmp 0x16fce
movb $0x2, %al
jmp 0x16fce
movb $0x3, %al
jmp 0x16fce
movb $-0x1, %al
movb %al, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8e5b(%rip), %rdi      # 0x1fe46
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17049
leaq 0x9ad8(%rip), %rdi      # 0x20ad6
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17050
leaq 0x9ad3(%rip), %rdi      # 0x20ae4
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17057
leaq 0x8cb1(%rip), %rdi      # 0x1fcd5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1705e
leaq 0x9a9a(%rip), %rdi      # 0x20ad1
movq %r14, %rsi
callq 0x4820
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x17067
jmp 0x17063
movl $0x2, %eax
jmp 0x17063
movl $0x4, %eax
jmp 0x17063
movl $0x3, %eax
jmp 0x17063
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x991c(%rip), %rdi      # 0x2099c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x170a3
leaq 0x9915(%rip), %rdi      # 0x209a8
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x170a7
xorl %eax, %eax
jmp 0x170b0
xorl %eax, %eax
jmp 0x170ac
movl $0x1, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x98ec(%rip), %rdi      # 0x209b5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x170ff
leaq 0x98e6(%rip), %rdi      # 0x209c2
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17103
leaq 0x98dd(%rip), %rdi      # 0x209cc
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1710a
xorl %eax, %eax
jmp 0x17113
xorl %eax, %eax
jmp 0x1710f
movl $0x1, %eax
jmp 0x1710f
movl $0x2, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x169bc
testb %al, %al
je 0x1713a
movzbl 0x7(%rsp), %eax
jmp 0x17170
leaq 0x9bb1(%rip), %rdi      # 0x20cf2
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x17164
leaq 0x9b4d(%rip), %rdi      # 0x20ca1
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x1716b
xorl %eax, %eax
jmp 0x17174
movl $0x2, %eax
jmp 0x17170
movl $0x3, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq