LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: window_grab_buttons
static void
window_grab_buttons(xcb_window_t win)
{
	for (int i = 0; i < NR_BUTTONS; i++) {
		if (conf.click_to_focus == (int8_t) XCB_BUTTON_INDEX_ANY ||
			conf.click_to_focus == (int8_t) mouse_buttons[i])
			window_grab_button(win, mouse_buttons[i], XCB_NONE);
		if (conf.pointer_actions[i] != POINTER_ACTION_NOTHING)
			window_grab_button(win, mouse_buttons[i], conf.pointer_modifier);
	}
	DMSG("grabbed buttons on 0x%08x\n", win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x62e1
movsbl 0x9593(%rip), %eax      # 0xf7f6
cmpl $0x0, %eax
je 0x6284
movsbl 0x9587(%rip), %eax      # 0xf7f6
movslq -0x8(%rbp), %rdx
leaq 0x5e6a(%rip), %rcx      # 0xc0e4
movl (%rcx,%rdx,4), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x629f
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rcx
leaq 0x5e52(%rip), %rax      # 0xc0e4
movl (%rax,%rcx,4), %eax
xorl %edx, %edx
movzbl %al, %esi
callq 0x62f0
movslq -0x8(%rbp), %rcx
leaq 0x9516(%rip), %rax      # 0xf7c0
cmpl $0x0, 0x28(%rax,%rcx,4)
je 0x62d1
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rcx
leaq 0x5e25(%rip), %rax      # 0xc0e4
movl (%rax,%rcx,4), %eax
movzbl %al, %esi
movzwl 0x9528(%rip), %edx      # 0xf7f4
callq 0x62f0
jmp 0x62d3
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6252
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: refresh_borders
static void
refresh_borders(void)
{
	if (!conf.apply_settings)
		return;

	struct list_item *item;
	struct client *client;

	for (item = win_list; item != NULL; item = item->next) {
		client = item->data;
		if (client->maxed)
			continue;

		if (client == focused_win)
			set_borders(client, conf.focus_color, conf.internal_focus_color);
		else
			set_borders(client, conf.unfocus_color, conf.internal_unfocus_color);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x9176(%rip)      # 0xf7e5
jne 0x6673
jmp 0x66e5
movq 0x8d6e(%rip), %rax      # 0xf3e8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x66e5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x669c
jmp 0x66d7
movq -0x10(%rbp), %rax
cmpq 0x9159(%rip), %rax      # 0xf800
jne 0x66c0
movq -0x10(%rbp), %rdi
movl 0x9115(%rip), %esi      # 0xf7c8
movl 0x9117(%rip), %edx      # 0xf7d0
callq 0x5d90
jmp 0x66d5
movq -0x10(%rbp), %rdi
movl 0x9102(%rip), %esi      # 0xf7cc
movl 0x9104(%rip), %edx      # 0xf7d4
callq 0x5d90
jmp 0x66d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x667e
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: free_window
static void
free_window(struct client *client)
{
	struct list_item *item;
	struct list_item *focus_item;

	DMSG("freeing 0x%08x\n", client->window);
	item = client->item;
	focus_item = client->focus_item;


	free(client);
	list_delete_item(&win_list, item);
	list_delete_item(&focus_list, focus_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32d0
movq -0x10(%rbp), %rsi
leaq 0x8cc0(%rip), %rdi      # 0xf3e8
callq 0xb7f0
movq -0x18(%rbp), %rsi
leaq 0x8cb8(%rip), %rdi      # 0xf3f0
callq 0xb7f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: update_client_list
static void
update_client_list(void)
{
	xcb_window_t *children;
	struct client *client;
	uint32_t len;

	xcb_query_tree_reply_t *reply = xcb_query_tree_reply(conn,
			xcb_query_tree(conn, scr->root), NULL);
	xcb_delete_property(conn, scr->root, ewmh->_NET_CLIENT_LIST);
	xcb_delete_property(conn, scr->root, ewmh->_NET_CLIENT_LIST_STACKING);

	if (reply == NULL) {
		add_to_client_list(0);
		return;
	}

	len = xcb_query_tree_children_length(reply);
	children = xcb_query_tree_children(reply);

	for (unsigned int i = 0; i < len; i++) {
		client = find_client(&children[i]);
		if (client != NULL)
			add_to_client_list(client->window);
	}

	free(reply);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x8c79(%rip), %rax      # 0xf3d8
movq %rax, -0x38(%rbp)
movq 0x8c6e(%rip), %rdi      # 0xf3d8
movq 0x9087(%rip), %rax      # 0xf7f8
movl (%rax), %esi
callq 0x3230
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3380
movq %rax, -0x20(%rbp)
movq 0x8c42(%rip), %rdi      # 0xf3d8
movq 0x905b(%rip), %rax      # 0xf7f8
movl (%rax), %esi
movq 0x8c3a(%rip), %rax      # 0xf3e0
movl 0x24(%rax), %edx
callq 0x3590
movl %eax, -0x28(%rbp)
movq 0x8c20(%rip), %rdi      # 0xf3d8
movq 0x9039(%rip), %rax      # 0xf7f8
movl (%rax), %esi
movq 0x8c18(%rip), %rax      # 0xf3e0
movl 0x28(%rax), %edx
callq 0x3590
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x67e3
xorl %edi, %edi
callq 0x6a80
jmp 0x684a
movq -0x20(%rbp), %rdi
callq 0x36b0
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34c0
movq %rax, -0x8(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6841
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x4ff0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6834
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x6a80
jmp 0x6836
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6803
movq -0x20(%rbp), %rdi
callq 0x32d0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: update_group_list
static void update_group_list(void)
{
	struct list_item *item;
	struct client *client;
	bool first = true;
	uint32_t data[1];

	for (unsigned int i = 0; i < conf.groups; i++) {
		/* deactivate group if no window in group */
		item = win_list;
		while (item != NULL && (client = item->data)->group != i)
			item = item->next;
		if (item == NULL)
			group_in_use[i] = false;

		if (group_in_use[i]) {
			uint8_t mode = XCB_PROP_MODE_APPEND;
			data[0] = i + 1;
			if (first) {
				mode = XCB_PROP_MODE_REPLACE;
				first = false;
			}
			xcb_change_property(conn, mode, scr->root, ATOMS[WINDOWCHEF_ACTIVE_GROUPS], XCB_ATOM_INTEGER, 32, 1, data);
		}
	}

	if (first) {
		data[0] = 0;
		xcb_change_property(conn, XCB_PROP_MODE_REPLACE, scr->root, ATOMS[WINDOWCHEF_ACTIVE_GROUPS], XCB_ATOM_INTEGER, 32, 1, data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb $0x1, -0x11(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x8f70(%rip), %eax      # 0xf7dc
jae 0x6949
movq 0x8b6f(%rip), %rax      # 0xf3e8
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x29(%rbp)
je 0x68a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x58(%rax), %eax
cmpl -0x1c(%rbp), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x68a9
jmp 0x68b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x687d
cmpq $0x0, -0x8(%rbp)
jne 0x68cc
movq 0x8f5b(%rip), %rax      # 0xf820
movl -0x1c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x8f4d(%rip), %rax      # 0xf820
movl -0x1c(%rbp), %ecx
testb $0x1, (%rax,%rcx)
je 0x6939
movb $0x2, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x68f7
movb $0x0, -0x1d(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x8ada(%rip), %rdi      # 0xf3d8
movb -0x1d(%rbp), %sil
movq 0x8eef(%rip), %rax      # 0xf7f8
movl (%rax), %edx
movl 0x8f03(%rip), %ecx      # 0xf814
leaq -0x18(%rbp), %rax
movl $0x13, %r8d
movl $0x20, %r9d
movzbl %sil, %esi
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x35b0
movl %eax, -0x24(%rbp)
jmp 0x693b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6863
testb $0x1, -0x11(%rbp)
je 0x6992
movl $0x0, -0x18(%rbp)
movq 0x8a7b(%rip), %rdi      # 0xf3d8
movq 0x8e94(%rip), %rax      # 0xf7f8
movl (%rax), %edx
movl 0x8ea8(%rip), %ecx      # 0xf814
leaq -0x18(%rbp), %rax
xorl %esi, %esi
movl $0x13, %r8d
movl $0x20, %r9d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x35b0
movl %eax, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: set_focused_last_best
static void
set_focused_last_best()
{
	struct list_item *focused_item;
	struct client *client;

	focused_item = focus_list->next;
	if (focused_item == NULL)
		focused_item = focus_list;

	while (focused_item != NULL) {
		client = focused_item->data;

		if (client != NULL && client->mapped) {
			set_focused(client);
			return;
		}

		focused_item = focused_item->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8a41(%rip), %rax      # 0xf3f0
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x69c9
movq 0x8a2b(%rip), %rax      # 0xf3f0
movq %rax, -0x8(%rbp)
jmp 0x69cb
cmpq $0x0, -0x8(%rbp)
je 0x6a07
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x69f9
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
je 0x69f9
movq -0x10(%rbp), %rdi
callq 0x6a10
jmp 0x6a07
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x69cb
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: get_pointer_location
static bool
get_pointer_location(xcb_window_t *win, int16_t *x, int16_t *y)
{
	xcb_query_pointer_reply_t *pointer;

	pointer = xcb_query_pointer_reply(conn,
			xcb_query_pointer(conn, *win), 0);

	*x = pointer->win_x;
	*y = pointer->win_y;

	free(pointer);

	return pointer != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x849d(%rip), %rax      # 0xf3d8
movq %rax, -0x30(%rbp)
movq 0x8492(%rip), %rdi      # 0xf3d8
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x3510
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3670
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw 0x14(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movw 0x16(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x32d0
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: group_add_window
static void
group_add_window(struct client *client, uint32_t group)
{
	if (client != NULL && group < conf.groups) {
		client->group = group;
		group_in_use[group] = true;
		update_wm_desktop(client);
		update_group_list();
		update_current_desktop(client);
		update_window_status(client);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6ff9
movl -0xc(%rbp), %eax
cmpl 0x881d(%rip), %eax      # 0xf7dc
jae 0x6ff9
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq 0x884e(%rip), %rax      # 0xf820
movl -0xc(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x7340
callq 0x6850
movq -0x8(%rbp), %rdi
callq 0x7210
movq -0x8(%rbp), %rdi
callq 0x5b70
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: find_monitor_by_coord
static struct monitor *
find_monitor_by_coord(int16_t x, int16_t y)
{
	struct list_item *item;
	struct monitor *m, *ret;

	m = ret = NULL;
	item = mon_list;
	while (item != NULL) {
		m = item->data;
		if (x >= m->x && x <= m->x + m->width
			&& y >= m->y && y <= m->y + m->height)
			ret = m;

		item = item->next;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x8807(%rip), %rax      # 0xf830
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x70a9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movswl -0x2(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jl 0x709b
movswl -0x2(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x10(%rcx), %ecx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x709b
movswl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jl 0x709b
movswl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x12(%rcx), %ecx
movq -0x18(%rbp), %rdx
movzwl 0x16(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x709b
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x702d
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: center_pointer
static void
center_pointer(struct client *client)
{
	int16_t cur_x, cur_y;

	cur_x = cur_y = 0;

	switch (conf.cursor_position) {
	case TOP_LEFT:
		cur_x = -conf.border_width;
		cur_y = -conf.border_width;
		break;
	case TOP_RIGHT:
		cur_x = client->geom.width + conf.border_width;
		cur_y = 0 - conf.border_width;
		break;
	case BOTTOM_LEFT:
		cur_x = 0 - conf.border_width;
		cur_y = client->geom.height + conf.border_width;
		break;
	case BOTTOM_RIGHT:
		cur_x = client->geom.width + conf.border_width;
		cur_y = client->geom.height + conf.border_width;
		break;
	case CENTER:
		cur_x = client->geom.width / 2;
		cur_y = client->geom.height / 2;
		break;
	default: break;
	}

	xcb_warp_pointer(conn, XCB_NONE, client->window, 0, 0, 0, 0, cur_x, cur_y);
	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xc(%rbp)
movw $0x0, -0xa(%rbp)
movl 0x870a(%rip), %eax      # 0xf7d8
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x71b5
movq -0x18(%rbp), %rax
leaq 0x4f1d(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x86c9(%rip), %ecx      # 0xf7c0
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movsbl 0x86ba(%rip), %ecx      # 0xf7c0
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x71b7
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movsbl 0x869e(%rip), %ecx      # 0xf7c0
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movsbl 0x8691(%rip), %ecx      # 0xf7c0
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x71b7
movsbl 0x8680(%rip), %ecx      # 0xf7c0
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movsbl 0x8669(%rip), %ecx      # 0xf7c0
addl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x71b7
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movsbl 0x8652(%rip), %ecx      # 0xf7c0
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movsbl 0x863d(%rip), %ecx      # 0xf7c0
addl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x71b7
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0xc(%rbp)
jmp 0x71b7
jmp 0x71b7
movq 0x821a(%rip), %rdi      # 0xf3d8
movq -0x8(%rbp), %rax
movl (%rax), %edx
movw -0xa(%rbp), %ax
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
cwtl
movl %eax, 0x8(%rsp)
movswl -0xc(%rbp), %eax
movl %eax, 0x10(%rsp)
callq 0x32b0
movl %eax, -0x10(%rbp)
movq 0x81e1(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: get_geometry
static bool
get_geometry(xcb_window_t *win, int16_t *x, int16_t *y, uint16_t *width, uint16_t *height, uint8_t *depth)
{
	xcb_get_geometry_reply_t *reply = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, *win), NULL);

	if (reply == NULL)
		return false;
	if (x != NULL)
		*x = reply->x;
	if (y != NULL)
		*y = reply->y;
	if (width != NULL)
		*width = reply->width;
	if (height != NULL)
		*height = reply->height;
	if (depth != NULL)
		*depth = reply->depth;

	free(reply);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq 0x8161(%rip), %rax      # 0xf3d8
movq %rax, -0x50(%rbp)
movq 0x8156(%rip), %rdi      # 0xf3d8
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x3390
movq -0x50(%rbp), %rdi
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3420
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x72b1
movb $0x0, -0x1(%rbp)
jmp 0x732a
cmpq $0x0, -0x18(%rbp)
je 0x72c7
movq -0x40(%rbp), %rax
movw 0xc(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x72dd
movq -0x40(%rbp), %rax
movw 0xe(%rax), %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x72f3
movq -0x40(%rbp), %rax
movw 0x10(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x7309
movq -0x40(%rbp), %rax
movw 0x12(%rax), %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x731d
movq -0x40(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x40(%rbp), %rdi
callq 0x32d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: vmaximize_window
static void
vmaximize_window(struct client *client, int16_t mon_y, uint16_t mon_height)
{
	if (client == NULL)
		return;

	if (is_special(client))
		reset_window(client);

	if (client->geom.height != mon_height)
		client->orig_geom = client->geom;

	client->geom.y = mon_y + conf.gap_up;
	client->geom.height = mon_height - conf.gap_up - conf.gap_down - 2 * conf.border_width;

	teleport_window(client->window, client->geom.x, client->geom.y);
	resize_window_absolute(client->window, client->geom.width, client->geom.height);
	client->vmaxed = true;

	update_ewmh_wm_state(client);
	update_window_status(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7596
jmp 0x7670
movq -0x8(%rbp), %rdi
callq 0x5780
testb $0x1, %al
jne 0x75a5
jmp 0x75ae
movq -0x8(%rbp), %rdi
callq 0x57f0
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
je 0x75d6
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x4(%rcx), %rdx
movq %rdx, 0xe(%rax)
movw 0xc(%rcx), %cx
movw %cx, 0x16(%rax)
movswl -0xa(%rbp), %eax
movsbl 0x81e4(%rip), %ecx      # 0xf7c5
addl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movzwl -0xc(%rbp), %eax
movsbl 0x81cc(%rip), %ecx      # 0xf7c5
subl %ecx, %eax
movsbl 0x81c2(%rip), %ecx      # 0xf7c4
subl %ecx, %eax
movsbl 0x81b5(%rip), %ecx      # 0xf7c0
shll %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x8(%rbp), %rax
movswl %cx, %esi
movswl 0x6(%rax), %edx
callq 0x5460
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x8(%rbp), %rax
movzwl %cx, %esi
movzwl 0xa(%rax), %edx
callq 0x54e0
movq -0x8(%rbp), %rax
movb $0x1, 0x26(%rax)
movq -0x8(%rbp), %rdi
callq 0x5ab0
movq -0x8(%rbp), %rdi
callq 0x5b70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: hmaximize_window
static void
hmaximize_window(struct client *client, int16_t mon_x, uint16_t mon_width)
{
	if (client == NULL)
		return;

	if (is_special(client))
		reset_window(client);

	if (client->geom.width != mon_width)
		client->orig_geom = client->geom;
	client->geom.x = mon_x + conf.gap_left;
	client->geom.width = mon_width - conf.gap_left - conf.gap_right - 2 * conf.border_width;

	teleport_window(client->window, client->geom.x, client->geom.y);
	resize_window_absolute(client->window, client->geom.width, client->geom.height);
	client->hmaxed = true;

	update_ewmh_wm_state(client);
	update_window_status(client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x76a6
jmp 0x7780
movq -0x8(%rbp), %rdi
callq 0x5780
testb $0x1, %al
jne 0x76b5
jmp 0x76be
movq -0x8(%rbp), %rdi
callq 0x57f0
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
je 0x76e6
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x4(%rcx), %rdx
movq %rdx, 0xe(%rax)
movw 0xc(%rcx), %cx
movw %cx, 0x16(%rax)
movswl -0xa(%rbp), %eax
movsbl 0x80d2(%rip), %ecx      # 0xf7c3
addl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movzwl -0xc(%rbp), %eax
movsbl 0x80ba(%rip), %ecx      # 0xf7c3
subl %ecx, %eax
movsbl 0x80b4(%rip), %ecx      # 0xf7c6
subl %ecx, %eax
movsbl 0x80a5(%rip), %ecx      # 0xf7c0
shll %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x8(%rbp), %rax
movswl %cx, %esi
movswl 0x6(%rax), %edx
callq 0x5460
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x8(%rbp), %rax
movzwl %cx, %esi
movzwl 0xa(%rax), %edx
callq 0x54e0
movq -0x8(%rbp), %rax
movb $0x1, 0x25(%rax)
movq -0x8(%rbp), %rdi
callq 0x5ab0
movq -0x8(%rbp), %rdi
callq 0x5b70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: get_randr
static void
get_randr(void)
{
	int len;
	xcb_randr_get_screen_resources_current_cookie_t c
		= xcb_randr_get_screen_resources_current(conn, scr->root);
	xcb_randr_get_screen_resources_current_reply_t *r
		= xcb_randr_get_screen_resources_current_reply(conn, c, NULL);

	if (r == NULL)
		return;

	xcb_timestamp_t timestamp = r->config_timestamp;
	len = xcb_randr_get_screen_resources_current_outputs_length(r);
	xcb_randr_output_t *outputs
		= xcb_randr_get_screen_resources_current_outputs(r);

	/* Request information for all outputs */
	get_outputs(outputs, len, timestamp);
	free(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x7c39(%rip), %rdi      # 0xf3d8
movq 0x8052(%rip), %rax      # 0xf7f8
movl (%rax), %esi
callq 0x3080
movl %eax, -0x8(%rbp)
movq 0x7c21(%rip), %rdi      # 0xf3d8
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x77d0
jmp 0x780b
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3350
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3520
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x7820
movq -0x10(%rbp), %rdi
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: find_clones
struct monitor *
find_clones(xcb_randr_output_t mon, int16_t x, int16_t y)
{
	struct monitor *clonemon;
	struct list_item *item;

	item = mon_list;
	while (item != NULL && ((clonemon = item->data)->monitor == mon
						|| clonemon->x != x
						|| clonemon->y != y)) {
		item = item->next;
	}

	if (item == NULL)
		return NULL;
	else
		return clonemon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movl %edi, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq 0x7c44(%rip), %rax      # 0xf830
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x7c42
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x22(%rbp)
je 0x7c3c
movq -0x18(%rbp), %rax
movswl 0x10(%rax), %ecx
movswl -0xe(%rbp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x22(%rbp)
jne 0x7c3c
movq -0x18(%rbp), %rax
movswl 0x12(%rax), %eax
movswl -0x10(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7c4b
jmp 0x7c59
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7bf0
cmpq $0x0, -0x20(%rbp)
jne 0x7c6a
movq $0x0, -0x8(%rbp)
jmp 0x7c72
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: find_monitor
struct monitor *
find_monitor(xcb_randr_output_t mon)
{
	struct list_item *item;
	struct monitor *m;

	item = mon_list;
	while (item != NULL && (m = item->data)->monitor != mon)
		item = item->next;

	if (item == NULL)
		return NULL;
	else
		return item->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq 0x7ba2(%rip), %rax      # 0xf830
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x7cb4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7cbd
jmp 0x7ccb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7c92
cmpq $0x0, -0x18(%rbp)
jne 0x7cdc
movq $0x0, -0x8(%rbp)
jmp 0x7ce7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: add_monitor
static struct monitor *
add_monitor(xcb_randr_output_t mon, char *name, int16_t x, int16_t y, uint16_t width, uint16_t height)
{
	struct list_item *item;
	struct monitor *monitor = malloc(sizeof(struct monitor));

	if (monitor == NULL)
		return NULL;

	item = list_add_item(&mon_list);
	if (item == NULL) {
		free(monitor);
		return NULL;
	}

	item->data = monitor;
	monitor->item = item;
	monitor->monitor = mon;
	monitor->name = name;
	monitor->x = x;
	monitor->y = y;
	monitor->width = width;
	monitor->height = height;

	return monitor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movl %ecx, %eax
movl -0x44(%rbp), %ecx
movl %eax, -0x40(%rbp)
movl %edx, %eax
movl -0x40(%rbp), %edx
movl %eax, -0x3c(%rbp)
movq %rsi, %rax
movl -0x3c(%rbp), %esi
movq %rax, -0x38(%rbp)
movl %edi, %r8d
movq -0x38(%rbp), %rdi
movw %r9w, %ax
movl %r8d, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movw %si, -0x1a(%rbp)
movw %dx, -0x1c(%rbp)
movw %cx, -0x1e(%rbp)
movw %ax, -0x20(%rbp)
movl $0x20, %edi
callq 0x31b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7d5b
movq $0x0, -0x8(%rbp)
jmp 0x7de9
leaq 0x7ace(%rip), %rdi      # 0xf830
callq 0xb750
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d85
movq -0x30(%rbp), %rdi
callq 0x32d0
movq $0x0, -0x8(%rbp)
jmp 0x7de9
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movw -0x1a(%rbp), %cx
movq -0x30(%rbp), %rax
movw %cx, 0x10(%rax)
movw -0x1c(%rbp), %cx
movq -0x30(%rbp), %rax
movw %cx, 0x12(%rax)
movw -0x1e(%rbp), %cx
movq -0x30(%rbp), %rax
movw %cx, 0x14(%rax)
movw -0x20(%rbp), %cx
movq -0x30(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: arrange_by_monitor
static void
arrange_by_monitor(struct monitor *mon)
{
	struct client *client;
	struct list_item *item;

	for (item = win_list; item != NULL; item = item->next) {
		client = item->data;

		if (client->monitor == mon)
			fit_on_screen(client);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x75d5(%rip), %rax      # 0xf3e8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7e50
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x7e40
movq -0x10(%rbp), %rdi
callq 0x5060
jmp 0x7e42
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7e17
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_move
static void
ipc_window_move(uint32_t *d)
{
	int16_t x, y;

	if (focused_win == NULL)
		return;

	if (is_special(focused_win)) {
		reset_window(focused_win);
		set_focused(focused_win);
	}

	x = d[2];
	y = d[3];
	if (d[0])
		x = -x;
	if (d[1])
		y = -y;

	focused_win->geom.x += x;
	focused_win->geom.y += y;

	move_window(focused_win->window, x, y);
	center_pointer(focused_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x71bc(%rip)      # 0xf800
jne 0x864b
jmp 0x8705
movq 0x71ae(%rip), %rdi      # 0xf800
callq 0x5780
testb $0x1, %al
jne 0x865d
jmp 0x8675
movq 0x719c(%rip), %rdi      # 0xf800
callq 0x57f0
movq 0x7190(%rip), %rdi      # 0xf800
callq 0x6a10
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x86a0
movswl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x86b6
movswl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %edx
movq 0x713f(%rip), %rax      # 0xf800
movswl 0x4(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x4(%rax)
movswl -0xc(%rbp), %edx
movq 0x712a(%rip), %rax      # 0xf800
movswl 0x6(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x6(%rax)
movq 0x7119(%rip), %rax      # 0xf800
movl (%rax), %edi
movw -0xa(%rbp), %ax
movswl %ax, %esi
movswl -0xc(%rbp), %edx
callq 0x9400
movq 0x7100(%rip), %rdi      # 0xf800
callq 0x70b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_move_absolute
static void
ipc_window_move_absolute(uint32_t *d)
{
	int16_t x, y;

	if (focused_win == NULL)
		return;

	if (is_special(focused_win)) {
		reset_window(focused_win);
		set_focused(focused_win);
	}

	x = d[2];
	y = d[3];

	if (d[0] == IPC_MUL_MINUS)
		x = -x;
	if (d[1] == IPC_MUL_MINUS)
		y = -y;

	focused_win->geom.x = x;
	focused_win->geom.y = y;

	teleport_window(focused_win->window, x, y);
	center_pointer(focused_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x70dc(%rip)      # 0xf800
jne 0x872b
jmp 0x87d9
movq 0x70ce(%rip), %rdi      # 0xf800
callq 0x5780
testb $0x1, %al
jne 0x873d
jmp 0x8755
movq 0x70bc(%rip), %rdi      # 0xf800
callq 0x57f0
movq 0x70b0(%rip), %rdi      # 0xf800
callq 0x6a10
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8780
movswl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8796
movswl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movw -0xa(%rbp), %cx
movq 0x705f(%rip), %rax      # 0xf800
movw %cx, 0x4(%rax)
movw -0xc(%rbp), %cx
movq 0x7050(%rip), %rax      # 0xf800
movw %cx, 0x6(%rax)
movq 0x7045(%rip), %rax      # 0xf800
movl (%rax), %edi
movw -0xa(%rbp), %ax
movswl %ax, %esi
movswl -0xc(%rbp), %edx
callq 0x5460
movq 0x702c(%rip), %rdi      # 0xf800
callq 0x70b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_resize
static void
ipc_window_resize(uint32_t *d)
{
	int16_t w, h;

	if (focused_win == NULL)
		return;

	if (is_special(focused_win)) {
		reset_window(focused_win);
		set_focused(focused_win);
	}

	w = d[2];
	h = d[3];

	if (d[0] == IPC_MUL_MINUS)
		w = -w;
	if (d[1] == IPC_MUL_MINUS)
		h = -h;

	resize_window(focused_win->window, w, h);
	center_pointer(focused_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x700c(%rip)      # 0xf800
jne 0x87fb
jmp 0x888b
movq 0x6ffe(%rip), %rdi      # 0xf800
callq 0x5780
testb $0x1, %al
jne 0x880d
jmp 0x8825
movq 0x6fec(%rip), %rdi      # 0xf800
callq 0x57f0
movq 0x6fe0(%rip), %rdi      # 0xf800
callq 0x6a10
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8850
movswl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8866
movswl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movq 0x6f93(%rip), %rax      # 0xf800
movl (%rax), %edi
movw -0xa(%rbp), %ax
movswl %ax, %esi
movswl -0xc(%rbp), %edx
callq 0x9510
movq 0x6f7a(%rip), %rdi      # 0xf800
callq 0x70b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_resize_absolute
static void
ipc_window_resize_absolute(uint32_t *d)
{
	int16_t w, h;

	if (focused_win == NULL)
		return;

	if (is_special(focused_win)) {
		reset_window(focused_win);
		set_focused(focused_win);
	}

	w = d[0];
	h = d[1];

	if (focused_win->min_width != 0 && w < focused_win->min_width)
		w = focused_win->min_width;

	if (focused_win->min_height != 0 && h < focused_win->min_height)
		h = focused_win->min_height;

	focused_win->geom.width = w;
	focused_win->geom.height = h;

	resize_window_absolute(focused_win->window, w, h);
	center_pointer(focused_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6f4c(%rip)      # 0xf800
jne 0x88bb
jmp 0x89a1
movq 0x6f3e(%rip), %rdi      # 0xf800
callq 0x5780
testb $0x1, %al
jne 0x88cd
jmp 0x88e5
movq 0x6f2c(%rip), %rdi      # 0xf800
callq 0x57f0
movq 0x6f20(%rip), %rdi      # 0xf800
callq 0x6a10
movq -0x8(%rbp), %rax
movl (%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movw %ax, -0xc(%rbp)
movq 0x6eff(%rip), %rax      # 0xf800
movzwl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x892c
movswl -0xa(%rbp), %eax
movq 0x6eeb(%rip), %rcx      # 0xf800
movzwl 0x48(%rcx), %ecx
cmpl %ecx, %eax
jge 0x892c
movq 0x6edc(%rip), %rax      # 0xf800
movw 0x48(%rax), %ax
movw %ax, -0xa(%rbp)
movq 0x6ecd(%rip), %rax      # 0xf800
movzwl 0x4a(%rax), %eax
cmpl $0x0, %eax
je 0x895e
movswl -0xc(%rbp), %eax
movq 0x6eb9(%rip), %rcx      # 0xf800
movzwl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jge 0x895e
movq 0x6eaa(%rip), %rax      # 0xf800
movw 0x4a(%rax), %ax
movw %ax, -0xc(%rbp)
movw -0xa(%rbp), %cx
movq 0x6e97(%rip), %rax      # 0xf800
movw %cx, 0x8(%rax)
movw -0xc(%rbp), %cx
movq 0x6e88(%rip), %rax      # 0xf800
movw %cx, 0xa(%rax)
movq 0x6e7d(%rip), %rax      # 0xf800
movl (%rax), %edi
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzwl -0xc(%rbp), %edx
callq 0x54e0
movq 0x6e64(%rip), %rdi      # 0xf800
callq 0x70b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_maximize
static void
ipc_window_maximize(uint32_t *d)
{
	(void)(d);
	int16_t mon_x, mon_y;
	uint16_t mon_w, mon_h;

	if (focused_win == NULL)
		return;

	if (focused_win->maxed) {
		reset_window(focused_win);
	} else {
		get_monitor_size(focused_win, &mon_x, &mon_y, &mon_w, &mon_h);
		maximize_window(focused_win, mon_x, mon_y, mon_w, mon_h);
	}

	set_focused(focused_win);

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6e3c(%rip)      # 0xf800
jne 0x89c8
jmp 0x8a3d
movq 0x6e31(%rip), %rax      # 0xf800
testb $0x1, 0x24(%rax)
je 0x89e3
movq 0x6e24(%rip), %rdi      # 0xf800
callq 0x57f0
jmp 0x8a25
movq 0x6e16(%rip), %rdi      # 0xf800
leaq -0xa(%rbp), %rsi
leaq -0xc(%rbp), %rdx
leaq -0xe(%rbp), %rcx
leaq -0x10(%rbp), %r8
callq 0x5550
movq 0x6dfa(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %dx
movw -0xc(%rbp), %cx
movw -0xe(%rbp), %ax
movswl %dx, %esi
movswl %cx, %edx
movzwl %ax, %ecx
movzwl -0x10(%rbp), %r8d
callq 0x5640
movq 0x6dd4(%rip), %rdi      # 0xf800
callq 0x6a10
movq 0x69a0(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_unmaximize
static void
ipc_window_unmaximize(uint32_t *d)
{
	(void)(d);

	if (focused_win == NULL)
		return;

	if (is_special(focused_win)) {
		reset_window(focused_win);
		set_focused(focused_win);
	}

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6d9c(%rip)      # 0xf800
jne 0x8a68
jmp 0x8a9e
movq 0x6d91(%rip), %rdi      # 0xf800
callq 0x5780
testb $0x1, %al
jne 0x8a7a
jmp 0x8a92
movq 0x6d7f(%rip), %rdi      # 0xf800
callq 0x57f0
movq 0x6d73(%rip), %rdi      # 0xf800
callq 0x6a10
movq 0x693f(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_hor_maximize
static void
ipc_window_hor_maximize(uint32_t *d)
{
	(void)(d);
	int16_t mon_x, mon_y;
	uint16_t mon_w;

	if (focused_win == NULL)
		return;

	if (focused_win->hmaxed) {
		reset_window(focused_win);
	} else {
		get_monitor_size(focused_win, &mon_x, &mon_y, &mon_w, NULL);
		hmaximize_window(focused_win, mon_x, mon_w);
	}

	set_focused(focused_win);

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6d3c(%rip)      # 0xf800
jne 0x8ac8
jmp 0x8b2f
movq 0x6d31(%rip), %rax      # 0xf800
testb $0x1, 0x25(%rax)
je 0x8ae3
movq 0x6d24(%rip), %rdi      # 0xf800
callq 0x57f0
jmp 0x8b17
movq 0x6d16(%rip), %rdi      # 0xf800
leaq -0xa(%rbp), %rsi
leaq -0xc(%rbp), %rdx
leaq -0xe(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5550
movq 0x6cf9(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %ax
movswl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x7680
movq 0x6ce2(%rip), %rdi      # 0xf800
callq 0x6a10
movq 0x68ae(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_ver_maximize
static void
ipc_window_ver_maximize(uint32_t *d)
{
	(void)(d);
	int16_t mon_x, mon_y;
	uint16_t mon_h;

	if (focused_win == NULL)
		return;

	if (focused_win->vmaxed) {
		reset_window(focused_win);
	} else {
		get_monitor_size(focused_win, &mon_x, &mon_y, NULL, &mon_h);
		vmaximize_window(focused_win, mon_y, mon_h);
	}

	set_focused(focused_win);

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6cac(%rip)      # 0xf800
jne 0x8b58
jmp 0x8bbe
movq 0x6ca1(%rip), %rax      # 0xf800
testb $0x1, 0x26(%rax)
je 0x8b73
movq 0x6c94(%rip), %rdi      # 0xf800
callq 0x57f0
jmp 0x8ba6
movq 0x6c86(%rip), %rdi      # 0xf800
leaq -0xa(%rbp), %rsi
leaq -0xc(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xe(%rbp), %r8
callq 0x5550
movq 0x6c6a(%rip), %rdi      # 0xf800
movw -0xc(%rbp), %ax
movswl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x7570
movq 0x6c53(%rip), %rdi      # 0xf800
callq 0x6a10
movq 0x681f(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_monocle
static void
ipc_window_monocle(uint32_t *d)
{
	(void)(d);
	int16_t mon_x, mon_y;
	uint16_t mon_w, mon_h;

	if (focused_win == NULL)
		return;

	if (focused_win->monocled) {
		reset_window(focused_win);
	} else {
		get_monitor_size(focused_win, &mon_x, &mon_y, &mon_w, &mon_h);
		monocle_window(focused_win, mon_x, mon_y, mon_w, mon_h);
	}

	set_focused(focused_win);

	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6c1c(%rip)      # 0xf800
jne 0x8be8
jmp 0x8c5d
movq 0x6c11(%rip), %rax      # 0xf800
testb $0x1, 0x27(%rax)
je 0x8c03
movq 0x6c04(%rip), %rdi      # 0xf800
callq 0x57f0
jmp 0x8c45
movq 0x6bf6(%rip), %rdi      # 0xf800
leaq -0xa(%rbp), %rsi
leaq -0xc(%rbp), %rdx
leaq -0xe(%rbp), %rcx
leaq -0x10(%rbp), %r8
callq 0x5550
movq 0x6bda(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %dx
movw -0xc(%rbp), %cx
movw -0xe(%rbp), %ax
movswl %dx, %esi
movswl %cx, %edx
movzwl %ax, %ecx
movzwl -0x10(%rbp), %r8d
callq 0x9680
movq 0x6bb4(%rip), %rdi      # 0xf800
callq 0x6a10
movq 0x6780(%rip), %rdi      # 0xf3d8
callq 0x3400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_put_in_grid
static void
ipc_window_put_in_grid(uint32_t *d)
{
	uint16_t grid_width, grid_height;
	uint16_t grid_x, grid_y;
	uint16_t occ_w, occ_h;
	const uint16_t m1 = 16U, m2 = 0xffffU;

	DMSG("data[4] = %d\n", d[4]);
	grid_width  = d[0] >> m1;
	grid_height = d[0] & m2;
	grid_x      = d[1] >> m1;
	grid_y      = d[1] & m2;
	occ_w       = d[2] >> m1;
	occ_h       = d[2] & m2;

	if (focused_win == NULL || grid_x >= grid_width || grid_y >= grid_height)
		return;

	grid_window(focused_win, grid_width, grid_height, grid_x, grid_y, occ_w, occ_h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movw $0x10, -0x16(%rbp)
movw $0xffff, -0x18(%rbp)    # imm = 0xFFFF
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x10, %eax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x10, %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x14(%rbp)
cmpq $0x0, 0x6af8(%rip)      # 0xf800
je 0x8d22
movzwl -0xe(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8d22
movzwl -0x10(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jl 0x8d24
jmp 0x8d5d
movq 0x6ad5(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %si
movw -0xc(%rbp), %dx
movw -0xe(%rbp), %cx
movw -0x10(%rbp), %r8w
movw -0x12(%rbp), %ax
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %r8w, %r8d
movzwl %ax, %r9d
movzwl -0x14(%rbp), %eax
movl %eax, (%rsp)
callq 0x9940
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_move_in_grid
static void
ipc_window_move_in_grid(uint32_t *d)
{
	uint16_t x, y;

	if (focused_win == NULL)
		return;

	x = d[2];
	y = d[3];

	if (d[0] == IPC_MUL_MINUS)
		x = -x;
	if (d[1] == IPC_MUL_MINUS)
		y = -y;

	move_grid_window(focused_win, x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6a7c(%rip)      # 0xf800
jne 0x8d88
jmp 0x8de0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8db3
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8dc9
movzwl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movq 0x6a30(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzwl -0xc(%rbp), %edx
callq 0x9c20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: ipc_window_resize_in_grid
static void
ipc_window_resize_in_grid(uint32_t *d)
{
	uint16_t x, y;

	if (focused_win == NULL)
		return;

	x = d[2];
	y = d[3];

	if (d[0] == IPC_MUL_MINUS)
		x = -x;
	if (d[1] == IPC_MUL_MINUS)
		y = -y;

	resize_grid_window(focused_win, x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x69fc(%rip)      # 0xf800
jne 0x8e08
jmp 0x8e60
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8e33
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8e49
movzwl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movq 0x69b0(%rip), %rdi      # 0xf800
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzwl -0xc(%rbp), %edx
callq 0x9d00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: move_window
static void
move_window(xcb_window_t win, int16_t x, int16_t y)
{
	int16_t win_x, win_y;
	uint16_t win_w, win_h;

	if (!is_mapped(win) || win == scr->root)
		return;

	get_geometry(&win, &win_x, &win_y, &win_w, &win_h, NULL);

	win_x += x;
	win_y += y;

	teleport_window(win, win_x, win_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x9490
testb $0x1, %al
jne 0x9427
jmp 0x9435
movl -0x4(%rbp), %eax
movq 0x63c7(%rip), %rcx      # 0xf7f8
cmpl (%rcx), %eax
jne 0x9437
jmp 0x9484
leaq -0x4(%rbp), %rdi
leaq -0xa(%rbp), %rsi
leaq -0xc(%rbp), %rdx
leaq -0xe(%rbp), %rcx
leaq -0x10(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x7250
movswl -0x6(%rbp), %ecx
movswl -0xa(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movswl -0x8(%rbp), %ecx
movswl -0xc(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movw -0xa(%rbp), %ax
movswl %ax, %esi
movswl -0xc(%rbp), %edx
callq 0x5460
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/wm.c
// Function: is_mapped
static bool
is_mapped(xcb_window_t win)
{
	bool yes;
	xcb_get_window_attributes_reply_t *r =
		xcb_get_window_attributes_reply(conn,
				xcb_get_window_attributes(conn, win),
				NULL);
	if (r == NULL)
		return false;

	yes = r->map_state == XCB_MAP_STATE_VIEWABLE;
	free(r);

	return yes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq 0x5f36(%rip), %rax      # 0xf3d8
movq %rax, -0x28(%rbp)
movq 0x5f2b(%rip), %rdi      # 0xf3d8
movl -0x8(%rbp), %esi
callq 0x34f0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x94d9
movb $0x0, -0x1(%rbp)
jmp 0x94fd
movq -0x18(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32d0
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)