LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: insert_into
void insert_into(int ws, window *win) {
	insert_into_helper(ws, TYPE_ALL, win);

	if (win->normal) {
		stack_above(win);
		insert_into_helper(ws, TYPE_NORMAL, win);
	} else {
		stack_above_abnormal(win);
	}
	
	if (win->above) {
		insert_into_helper(ws, TYPE_ABOVE, win);
	} else if (!win->is_i_full && !win->is_e_full) {
		safe_traverse(ws, TYPE_ABOVE, mywm_raise);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %r14
leaq (%r14,%r14,4), %rax
shlq $0x4, %rax
leaq 0x726c(%rip), %rcx      # 0xd930
leaq (%rax,%rcx), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rsi
leaq (,%r14,8), %rdi
leaq (%rdi,%rdi,2), %r12
movq %rsi, (%rbx,%r12)
movq $0x0, 0x60(%rbx,%r12)
movq -0x8(%rdx), %rsi
testq %rsi, %rsi
leaq 0x60(%rsi,%r12), %rsi
cmoveq %rdx, %rsi
movq %rbx, (%rsi)
movq %rbx, -0x8(%rdx)
incl 0x8(%rdx)
leaq (%rcx,%rax), %r15
leaq 0x60(%rbx), %r13
cmpl $0x0, 0xc0(%rbx)
je 0x6742
movq %rbx, %rdi
callq 0x4f14
movq 0x18(%r15), %rax
movq %rax, 0x8(%rbx,%r12)
movq $0x0, 0x8(%r13,%r12)
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x674c
leaq (%r14,%r14,2), %rcx
movq %rbx, 0x68(%rax,%rcx,8)
jmp 0x6750
movq %rbx, %rdi
callq 0x4ee2
jmp 0x6758
movq %rbx, 0x20(%r15)
movq %rbx, 0x18(%r15)
incl 0x28(%r15)
cmpl $0x0, 0xc4(%rbx)
je 0x6794
movq 0x30(%r15), %rax
movq %rax, 0x10(%rbx,%r12)
movq $0x0, 0x10(%r13,%r12)
movq 0x30(%r15), %rax
leaq 0x38(%r15), %rcx
testq %rax, %rax
leaq 0x70(%rax,%r12), %rax
cmoveq %rcx, %rax
movq %rbx, (%rax)
movq %rbx, 0x30(%r15)
incl 0x40(%r15)
jmp 0x67c5
cmpl $0x0, 0x18c(%rbx)
jne 0x67c5
cmpl $0x0, 0x190(%rbx)
jne 0x67c5
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x67c5
leaq (%r14,%r14,2), %rbx
movq 0x10(%rdi,%rbx,8), %r14
callq 0x4f46
movq %r14, %rdi
testq %r14, %r14
jne 0x67b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: append_to
void append_to(int ws, window *win) {
	append_to_helper(ws, TYPE_ALL, win);

	if (win->normal) {
		stack_below(win);
		append_to_helper(ws, TYPE_NORMAL, win);
	} else {
		stack_below_abnormal(win);
	}

	if (win->above) {
		fprintf(stderr, "mywm: can't append always-above windows.\n");
		return;
	} else {
		//handle always-below :^)
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %edi, %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x713c(%rip), %rdx      # 0xd930
leaq (%rdx,%rcx), %r14
movq 0x8(%rcx,%rdx), %rsi
leaq (,%rax,8), %rdi
leaq (%rdi,%rdi,2), %r15
movq %rsi, 0x60(%rbx,%r15)
movq $0x0, (%rbx,%r15)
movq 0x8(%rcx,%rdx), %rcx
testq %rcx, %rcx
je 0x682a
leaq (%rax,%rax,2), %rax
movq %rbx, (%rcx,%rax,8)
jmp 0x682d
movq %rbx, (%r14)
movq %rbx, 0x8(%r14)
incl 0x10(%r14)
cmpl $0x0, 0xc0(%rbx)
je 0x687d
leaq 0x60(%rbx), %r12
movq %rbx, %rdi
callq 0x4eb0
movq 0x20(%r14), %rax
movq %rax, 0x8(%r12,%r15)
movq $0x0, 0x8(%rbx,%r15)
movq 0x20(%r14), %rax
leaq 0x18(%r14), %rcx
testq %rax, %rax
leaq 0x8(%rax,%r15), %rax
cmoveq %rcx, %rax
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
incl 0x28(%r14)
jmp 0x6885
movq %rbx, %rdi
callq 0x4e7e
cmpl $0x0, 0xc4(%rbx)
jne 0x6897
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3694
jmp 0x688e
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: excise_from
void excise_from(int ws, window *win) {
	if (win->normal) {
		excise_from_helper(ws, TYPE_NORMAL, win);
	}

	if (win->above) {
		excise_from_helper(ws, TYPE_ABOVE, win);
	}
	
	excise_from_helper(ws, TYPE_ALL, win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x0, 0xc0(%rsi)
je 0x68c4
movl %r14d, %edi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x68eb
cmpl $0x0, 0xc4(%rbx)
je 0x68dd
movl %r14d, %edi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x68eb
movl %r14d, %edi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x68eb
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: excise_from_helper
static void excise_from_helper(int ws, int type, window *subj) {
	if (subj->next[ws][type]) {
		subj->next[ws][type]->prev[ws][type] = subj->prev[ws][type];
	} else {
		stack[ws].lists[type].last = subj->prev[ws][type];
	}
	
	if (subj->prev[ws][type]) {
		subj->prev[ws][type]->next[ws][type] = subj->next[ws][type];
	} else {
		stack[ws].lists[type].first = subj->next[ws][type];
	}
	
	stack[ws].lists[type].count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rax
movl %esi, %ecx
leaq (,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rsi, %rdx
movq (%rdx,%rcx,8), %rdi
movq 0x60(%rdx,%rcx,8), %r8
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x7015(%rip), %r9       # 0xd930
addq %rax, %r9
leaq (%rdi,%rsi), %rax
testq %rdi, %rdi
leaq (%rcx,%rcx,2), %rdi
leaq (%r9,%rdi,8), %r10
leaq 0x8(%r9,%rdi,8), %rdi
leaq 0x60(%rax,%rcx,8), %rax
cmoveq %rdi, %rax
movq %r8, (%rax)
movq (%rdx,%rcx,8), %rax
movq 0x60(%rdx,%rcx,8), %rdx
addq %rdx, %rsi
testq %rdx, %rdx
leaq (%rsi,%rcx,8), %rcx
cmoveq %r10, %rcx
movq %rax, (%rcx)
decl 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: search_helper
search_data search_helper(int ws, int type, xcb_window_t id, int (*func)(window *, xcb_window_t)) {
	search_data ret;
	for (ret.win = stack[ws].lists[type].first; ret.win; ret.win = ret.win->next[ws][type]) {
		ret.index = func(ret.win, id);
		if (-1 < ret.index) {
			return ret;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movslq %edi, %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x6eff(%rip), %rdx      # 0xd930
addq %rcx, %rdx
movslq %esi, %r12
leaq (%r12,%r12,2), %rcx
movq (%rdx,%rcx,8), %r15
testq %r15, %r15
je 0x6a65
leaq (%rax,%rax,2), %r13
movq %r15, %rdi
movl %r14d, %esi
callq *%rbx
movl %eax, %edx
testl %eax, %eax
jns 0x6a65
leaq (%r15,%r13,8), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
jne 0x6a48
jmp 0x6a65
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: search_range
search_data search_range(int ws, int type, int start_index, int end_index, xcb_window_t id) {
	search_data ret;
	for (ret.win = stack[ws].lists[type].first; ret.win; ret.win = ret.win->next[ws][type]) {
		for (int i = start_index; i < end_index; i++) {
			if (ret.win->windows[i] == id) {
				ret.index = i;
				return ret;
			}
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %edi, %r14
leaq (%r14,%r14,4), %rax
shlq $0x4, %rax
leaq 0x6e9a(%rip), %r9       # 0xd930
addq %rax, %r9
movslq %esi, %rdi
leaq (%rdi,%rdi,2), %rax
movq (%r9,%rax,8), %rax
testq %rax, %rax
je 0x6b1c
cmpl %ecx, %edx
setl %r9b
movslq %edx, %r10
movslq %ecx, %r11
leaq -0x1(%r11), %rbx
leaq (%r14,%r14,2), %r14
cmpl %ecx, %edx
jge 0x6af3
movq %r10, %r12
movl %r9d, %r13d
movl %edx, %esi
cmpl %r8d, 0xcc(%rax,%r10,4)
je 0x6b05
cmpq %r12, %rbx
je 0x6af8
leaq 0x1(%r12), %rsi
cmpl %r8d, 0xd0(%rax,%r12,4)
movq %rsi, %r12
jne 0x6ad3
cmpq %r11, %rsi
setl %r13b
jmp 0x6b05
movl %r9d, %r13d
jmp 0x6b02
incq %r12
cmpq %r11, %r12
setl %r13b
movl %r15d, %esi
testb %r13b, %r13b
jne 0x6b1c
leaq (%rax,%r14,8), %rax
movq (%rax,%rdi,8), %rax
movl %esi, %r15d
testq %rax, %rax
jne 0x6abd
jmp 0x6b1c
movl %esi, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: search_ws
window *search_ws(int ws, int type, int window_index, xcb_window_t id) {
	window *cur;
	for (cur = stack[ws].lists[type].first; cur; cur = cur->next[ws][type]) {
		if (cur->windows[window_index] == id) {
			break;
		}
	}
	return cur;
}

// Assembly:
movslq %edi, %rdi
leaq (%rdi,%rdi,4), %rax
shlq $0x4, %rax
leaq 0x6df5(%rip), %r8       # 0xd930
addq %rax, %r8
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rax
movq (%r8,%rax,8), %rax
testq %rax, %rax
je 0x6b70
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rdx
leaq (%rdi,%rdi,2), %rdi
cmpl %ecx, 0xcc(%rax,%rdx,4)
je 0x6b6f
leaq (%rax,%rdi,8), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x6b59
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: search_all
window *search_all(int *ws, int type, int window_index, xcb_window_t id) {
	window *ret;
	for (int i = 0; i < NUM_WS; i++) {
		ret = search_ws(i, type, window_index, id);
		if (ret) {
			if (ws) {
				*ws = i;
			}
			break;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rax
leaq 0x6dad(%rip), %r8       # 0xd930
leaq (%r8,%rax,8), %r8
movslq %edx, %r9
xorl %edx, %edx
leaq (%rdx,%rdx,4), %rax
shlq $0x4, %rax
movq (%r8,%rax), %rax
testq %rax, %rax
je 0x6bb8
leaq (%rdx,%rdx,2), %r10
cmpl %ecx, 0xcc(%rax,%r9,4)
je 0x6bb8
leaq (%rax,%r10,8), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x6ba1
testq %rax, %rax
jne 0x6bca
incq %rdx
cmpq $0x4, %rdx
jne 0x6b8c
xorl %eax, %eax
jmp 0x6bd1
testq %rdi, %rdi
je 0x6bd1
movl %edx, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/workspace.c
// Function: refocus
void refocus(int ws) {
	window *win = stack[ws].lists[TYPE_NORMAL].first;
	if (!win) {
		xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT,
				scr->root, XCB_CURRENT_TIME);
		return;
	}

	/*if (win->is_i_full || win->is_e_full) {
		mywm_raise(win);
	}*/

	focus(win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6d47(%rip), %rcx      # 0xd930
movq 0x18(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x6bf9
popq %rbp
jmp 0x514d
leaq 0x6848(%rip), %rax      # 0xd448
movq (%rax), %rdi
leaq 0x6846(%rip), %rax      # 0xd450
movq (%rax), %rax
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
popq %rbp
jmp 0x3150
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: close
void close(void *arg) {
	if (!stack[curws].fwin) {
		return;
	}

	xcb_unmap_window(conn, stack[curws].fwin->windows[WIN_PARENT]);
	xcb_unmap_window(conn, stack[curws].fwin->windows[WIN_CHILD]);

	close_helper(stack[curws].fwin->windows[WIN_CHILD]);

	forget_client(stack[curws].fwin, curws);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6e14(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6cc2(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rax
testq %rax, %rax
je 0x6ce5
leaq 0x67c9(%rip), %r15      # 0xd448
movq (%r15), %rdi
movl 0xd0(%rax), %esi
callq 0x3570
movq (%r15), %rdi
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r14,%rax), %rax
movl 0xcc(%rax), %esi
callq 0x3570
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r14,%rax), %rax
movl 0xcc(%rax), %edi
callq 0x37e6
movslq (%rbx), %rsi
leaq (%rsi,%rsi,4), %rax
shlq $0x4, %rax
movq 0x48(%r14,%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5781
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: select_window_terminate
void select_window_terminate(void) {
	state = DEFAULT;
	events[XCB_ENTER_NOTIFY] = enter_notify;
	events[XCB_LEAVE_NOTIFY] = leave_notify;
	traverse(curws, TYPE_NORMAL, reset_events);
	select_window_handler = select_window_init;
	free(select_window_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6749(%rip), %rax      # 0xd444
movl $0x0, (%rax)
leaq -0x3450(%rip), %rax     # 0x38b8
leaq 0x67c1(%rip), %rcx      # 0xd4d0
movq %rax, 0x38(%rcx)
leaq -0x33ae(%rip), %rax     # 0x396c
movq %rax, 0x40(%rcx)
leaq 0x6d4b(%rip), %rax      # 0xda70
movl (%rax), %edi
leaq -0x1fbd(%rip), %rdx     # 0x4d71
movl $0x1, %esi
callq 0x65fd
leaq 0x14(%rip), %rax        # 0x6d53
movq %rax, 0x660a(%rip)      # 0xd350
movq 0x6d2b(%rip), %rdi      # 0xda78
popq %rbp
jmp 0x3280
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: select_window_init
static void select_window_init(void) {
	state = SELECT_WINDOW;
	events[XCB_ENTER_NOTIFY] = NULL;
	events[XCB_LEAVE_NOTIFY] = NULL;
	traverse(curws, TYPE_NORMAL, release_events);

	int count = stack[curws].lists[TYPE_NORMAL].count;
	select_window_list = malloc(count * sizeof(window *));

	window *cur = stack[curws].lists[TYPE_NORMAL].first;
	for (int i = 0; i < count && cur; i++) {
		if (cur == stack[curws].fwin) {
			select_window_index = i;
		}

		select_window_list[i] = cur;
		cur = cur->next[curws][TYPE_NORMAL];
	}

	select_window_handler = select_window_iterate;
	select_window_iterate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x66dc(%rip), %rax      # 0xd444
movl $0x3, (%rax)
xorps %xmm0, %xmm0
leaq 0x6758(%rip), %rax      # 0xd4d0
movups %xmm0, 0x38(%rax)
leaq 0x6ced(%rip), %rbx      # 0xda70
movl (%rbx), %edi
leaq -0x2050(%rip), %rdx     # 0x4d3c
movl $0x1, %esi
callq 0x65fd
movslq (%rbx), %r14
leaq (%r14,%r14,4), %r15
shlq $0x4, %r15
leaq 0x6b88(%rip), %r12      # 0xd930
movslq 0x28(%r12,%r15), %rbx
testq %rbx, %rbx
setg %r13b
leaq (,%rbx,8), %rdi
callq 0x3170
movq %rax, 0x6cb0(%rip)      # 0xda78
movq 0x18(%r12,%r15), %rcx
testq %rcx, %rcx
setne %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x6e07
movq 0x48(%r12,%r15), %rdx
xorl %esi, %esi
leaq (%r14,%r14,2), %rdi
cmpq %rdx, %rcx
jne 0x6df1
movl %esi, 0x6c8f(%rip)      # 0xda80
movq %rcx, (%rax,%rsi,8)
incq %rsi
cmpq %rbx, %rsi
jae 0x6e07
movq 0x8(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x6de6
leaq 0x513(%rip), %rax       # 0x7321
movq %rax, 0x653b(%rip)      # 0xd350
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7321
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: select_window
void select_window(void *arg) {
	window *stack_curws = stack[curws].lists[TYPE_NORMAL].first;
	if (!stack_curws || !stack_curws->next[curws][TYPE_NORMAL]) {
		return;
	}

	select_window_handler();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6c3d(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x6aeb(%rip), %rdx      # 0xd930
movq 0x18(%rdx,%rcx), %rcx
testq %rcx, %rcx
je 0x6e62
leaq (%rax,%rax,2), %rax
cmpq $0x0, 0x8(%rcx,%rax,8)
je 0x6e62
popq %rbp
jmpq *0x64ee(%rip)           # 0xd350
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: change_ws
void change_ws(void *arg) {
	int new_ws = *(int *)arg;

	printf("ws: %d\n", new_ws);

	if (new_ws == curws) {
		return;
	}

	if (stack[curws].fwin) {
		unfocus(stack[curws].fwin);
	}

	traverse(curws, TYPE_NORMAL, hide); 
	xcb_ewmh_set_current_desktop(ewmh, 0, new_ws);
	traverse(new_ws, TYPE_NORMAL, show);

	curws = new_ws;

	if (stack[new_ws].fwin) {
		focus(stack[new_ws].fwin);
	} else {
		refocus(new_ws);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %ebx
leaq 0x2393(%rip), %rdi      # 0x920b
movl %ebx, %esi
xorl %eax, %eax
callq 0x3060
leaq 0x6be8(%rip), %r14      # 0xda70
movslq (%r14), %rax
cmpl %eax, %ebx
jne 0x6e98
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq %ebx, %r15
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6a86(%rip), %r12      # 0xd930
movq 0x48(%r12,%rax), %rdi
testq %rdi, %rdi
je 0x6eb9
callq 0x4fe1
movl (%r14), %edi
leaq -0x1bf3(%rip), %rdx     # 0x52d0
movl $0x1, %esi
callq 0x65fd
leaq 0x6584(%rip), %rax      # 0xd458
movq (%rax), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x3540
leaq -0x1c5a(%rip), %rdx     # 0x528d
movl %ebx, %edi
movl $0x1, %esi
callq 0x65fd
movl %ebx, (%r14)
leaq (%r15,%r15,4), %rax
shlq $0x4, %rax
movq 0x48(%r12,%rax), %rdi
testq %rdi, %rdi
je 0x6f15
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x514d
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6bd3
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: send_ws
void send_ws(void *arg) {
	int new_ws = *(int *)arg;

	if (!stack[curws].fwin || new_ws == curws || stack[curws].fwin->sticky) {
		return;
	}

	stack[curws].fwin->ignore_unmap = 1;
	xcb_unmap_window(conn, stack[curws].fwin->windows[WIN_PARENT]);

	excise_from(curws, stack[curws].fwin);
	insert_into(new_ws, stack[curws].fwin);
	stack[curws].fwin = NULL;

	refocus(curws);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %ebx
leaq 0x6b39(%rip), %r14      # 0xda70
movl (%r14), %eax
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rax
shlq $0x4, %rax
leaq 0x69e4(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
testq %rax, %rax
sete %dl
cmpl %ecx, %ebx
sete %cl
orb %dl, %cl
jne 0x6f69
cmpl $0x0, 0xc8(%rax)
je 0x6f74
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, 0x194(%rax)
leaq 0x64c3(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
movl 0xd0(%rax), %esi
callq 0x3570
movslq (%r14), %rdi
leaq (%rdi,%rdi,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rsi
callq 0x689e
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rsi
movl %ebx, %edi
callq 0x66a1
movslq (%r14), %rdi
leaq (%rdi,%rdi,4), %rax
shlq $0x4, %rax
movq $0x0, 0x48(%r15,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bd3
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: int_full
void int_full(void *arg) {
	if (!stack[curws].fwin) {
		return;
	}

	stack[curws].fwin->is_i_full = !stack[curws].fwin->is_i_full;

	if (stack[curws].fwin->is_e_full) {
		return;
	}

	if (!stack[curws].fwin->is_i_full) {
		full_restore_state(stack[curws].fwin); 
		return;
	}
	
	full_save_state(stack[curws].fwin);

	full(stack[curws].fwin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x6a08(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x68b6(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rdi
testq %rdi, %rdi
je 0x70a0
movl 0x18c(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0x18c(%rdi)
cmpl $0x0, 0x190(%rdi)
je 0x70a5
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
je 0x70b2
popq %rbx
popq %r14
popq %rbp
jmp 0x5434
callq 0x5406
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r14,%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x567d
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: mouse_roll_up
void mouse_roll_up(void *arg) {
	press_arg *info = (press_arg *)arg;

	window *found = search_ws(curws, TYPE_NORMAL, WIN_PARENT, info->win);
	if (!found || !found->normal || found != stack[curws].fwin || found->is_roll) {
		return;
	}
	
	found->before_roll = found->geom[GEOM_H];

	uint32_t val = PAD_N;
	update_geometry(found, XCB_CONFIG_WINDOW_HEIGHT, &val);
	
	found->is_roll = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x684b(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b29
testq %rax, %rax
je 0x729b
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x729b
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x66d2(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x729b
cmpl $0x0, 0x164(%rbx)
jne 0x729b
movl 0x114(%rbx), %eax
movl %eax, 0x160(%rbx)
leaq -0x14(%rbp), %rdx
movl $0x20, (%rdx)
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5464
movl $0x1, 0x164(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: mouse_roll_down
void mouse_roll_down(void *arg) {
	press_arg *info = (press_arg *)arg;

	window *found = search_ws(curws, TYPE_NORMAL, WIN_PARENT, info->win);
	if (!found || !found->normal || found != stack[curws].fwin || !found->is_roll) {
		return;
	}

	update_geometry(found, XCB_CONFIG_WINDOW_HEIGHT, &found->before_roll);
	
	found->is_roll = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x67be(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b29
testq %rax, %rax
je 0x731c
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x731c
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6645(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x731c
cmpl $0x0, 0x164(%rbx)
je 0x731c
movq %rbx, %rdx
addq $0x160, %rdx            # imm = 0x160
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5464
movl $0x0, 0x164(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/action.c
// Function: select_window_iterate
static void select_window_iterate(void) {
	for (int i = select_window_index; i >= 0; i--) {
		mywm_raise(select_window_list[i]);
	}

	unsigned int new_index = select_window_index + 1;
	if (new_index < stack[curws].lists[TYPE_NORMAL].count) {
		select_window_index = new_index;
	} else {
		select_window_index = 0;
	}

	window *win = select_window_list[select_window_index];
	mywm_raise(win);
	center_pointer(win);
	focus(win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x6752(%rip), %rbx      # 0xda80
testq %rbx, %rbx
js 0x734c
incq %rbx
movq 0x673b(%rip), %rax      # 0xda78
movq -0x8(%rax,%rbx,8), %rdi
callq 0x4f46
decq %rbx
jg 0x7336
movl 0x672e(%rip), %eax      # 0xda80
incl %eax
leaq 0x6715(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x65c3(%rip), %rdx      # 0xd930
xorl %esi, %esi
cmpl 0x28(%rdx,%rcx), %eax
cmovbl %eax, %esi
movl %esi, 0x6704(%rip)      # 0xda80
movq 0x66f5(%rip), %rax      # 0xda78
movq (%rax,%rsi,8), %rbx
movq %rbx, %rdi
callq 0x4f46
movq %rbx, %rdi
callq 0x4ddb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x514d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: button_release
void button_release(void *arg) {
	deactivate_margins();

	xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
	state = DEFAULT;

	events[XCB_MOTION_NOTIFY] = NULL; //jic
	events[XCB_BUTTON_RELEASE] = NULL; //jic
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
callq 0x877e
leaq 0x608e(%rip), %rax      # 0xd448
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3050
leaq 0x6079(%rip), %rax      # 0xd444
movl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x60f5(%rip), %rax      # 0xd4d0
movups %xmm0, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_move
void mouse_move(void *arg) {
	press_arg *info = (press_arg *)arg;

	xcb_get_geometry_reply_t *geom;
	
	if (!move_resize_helper(info->win, &geom)) {
		return;
	}

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_move_motion_start;
	events[XCB_BUTTON_RELEASE] = (void (*)(xcb_generic_event_t *))button_release;

	if (stack[curws].fwin->snap_index != SNAP_NONE) {
		x = stack[curws].fwin->before_snap[GEOM_W] *
				(info->event_x - stack[curws].fwin->geom[GEOM_X]) /
				stack[curws].fwin->geom[GEOM_W];
		y = stack[curws].fwin->before_snap[GEOM_H] *
				(info->event_y - stack[curws].fwin->geom[GEOM_Y]) /
				stack[curws].fwin->geom[GEOM_H];
	} else {
		x = info->event_x - stack[curws].fwin->geom[GEOM_X];
		y = info->event_y - stack[curws].fwin->geom[GEOM_Y];
	}
	
	state = MOVE;
	
	activate_margins();

	grab_pointer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7497
leaq 0x179(%rip), %rax       # 0x75b9
leaq 0x6089(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
leaq -0xaa(%rip), %rax       # 0x73a8
movq %rax, 0x28(%rcx)
leaq 0x6613(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x64c1(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rcx
cmpl $0x7, 0x178(%rcx)
jne 0x74a0
movl 0x4(%rbx), %eax
subl 0x108(%rcx), %eax
movl %eax, 0x65f8(%rip)      # 0xda84
movl 0x8(%rbx), %eax
subl 0x10c(%rcx), %eax
jmp 0x74d6
addq $0x8, %rsp
jmp 0x752e
movl 0x4(%rbx), %eax
subl 0x108(%rcx), %eax
imull 0x170(%rcx), %eax
xorl %edx, %edx
divl 0x110(%rcx)
movl %eax, 0x65c6(%rip)      # 0xda84
movl 0x8(%rbx), %eax
subl 0x10c(%rcx), %eax
imull 0x174(%rcx), %eax
xorl %edx, %edx
divl 0x114(%rcx)
movl %eax, 0x65ac(%rip)      # 0xda88
leaq 0x5f61(%rip), %rax      # 0xd444
movl $0x1, (%rax)
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8720
leaq 0x5f4f(%rip), %rax      # 0xd448
movq (%rax), %rdi
leaq 0x5f4d(%rip), %rax      # 0xd450
movq (%rax), %rax
movl (%rax), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rbx
pushq %rbx
pushq %rdx
callq 0x3160
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: move_resize_helper
static int move_resize_helper(xcb_window_t win, xcb_get_geometry_reply_t **geom) {
	window *found = search_ws(curws, TYPE_NORMAL, WIN_PARENT, win);
	if (!found || !found->normal || found != stack[curws].fwin) {
		return 0;
	}

	safe_raise(stack[curws].fwin);
	
	if (stack[curws].fwin->is_e_full || stack[curws].fwin->is_i_full) {
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ecx
leaq 0x652c(%rip), %r14      # 0xda70
movl (%r14), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b29
xorl %ebx, %ebx
testq %rax, %rax
je 0x75ac
cmpl $0x0, 0xc0(%rax)
je 0x75ac
movslq (%r14), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x63b8(%rip), %r15      # 0xd930
movq 0x48(%r15,%rcx), %rdi
cmpq %rdi, %rax
jne 0x75ac
callq 0x4f9c
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rax
cmpl $0x0, 0x190(%rax)
jne 0x75ac
xorl %ebx, %ebx
cmpl $0x0, 0x18c(%rax)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_move_motion_start
static void mouse_move_motion_start(void *arg) {
	if (stack[curws].fwin->snap_index != SNAP_NONE) {
		snap_restore_state(stack[curws].fwin);
	}

	mouse_move_motion(NULL);
	
	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_move_motion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x64ac(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x635a(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
cmpl $0x7, 0x178(%rdi)
je 0x75e9
callq 0x83bb
callq 0x7ed9
leaq 0x8e4(%rip), %rax       # 0x7ed9
leaq 0x5ed4(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_south_east
void mouse_resize_south_east(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[4]);
	
	mouse_resize_set_x_east((press_arg *)arg);
	mouse_resize_set_y_south((press_arg *)arg);

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_south_east_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x76d0
xorps %xmm0, %xmm0
leaq 0x5eab(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x92d(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x5e08(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x62c7(%rip), %rax      # 0xd910
movl 0x10(%rax), %eax
leaq 0x5df5(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5df3(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
leaq 0x63e0(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x628e(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x63ce(%rip)      # 0xda84
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x63c3(%rip)      # 0xda88
leaq 0x9(%rip), %rax         # 0x76d5
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_south
void mouse_resize_south(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}

	grab_pointer_cursor(resize_cursors[5]);
	
	mouse_resize_set_y_south((press_arg *)arg);

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_south_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x77d9
xorps %xmm0, %xmm0
leaq 0x5d93(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x815(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x5cf0(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x61af(%rip), %rax      # 0xd910
movl 0x14(%rax), %eax
leaq 0x5cdd(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5cdb(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
leaq 0x62c8(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6176(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x62ba(%rip)      # 0xda88
leaq 0x9(%rip), %rax         # 0x77de
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north
void mouse_resize_north(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[1]);
	
	mouse_resize_set_y_north((press_arg *)arg);
	mouse_resize_set_south();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_north_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x78f0
xorps %xmm0, %xmm0
leaq 0x5c8a(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x70c(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x5be7(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x60a6(%rip), %rax      # 0xd910
movl 0x4(%rax), %eax
leaq 0x5bd4(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5bd2(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
movl 0x8(%rbx), %eax
leaq 0x61bc(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x606a(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x10c(%rcx), %edx
subl %edx, %eax
movl %eax, 0x61af(%rip)      # 0xda88
addl 0x114(%rcx), %edx
movl %edx, 0x61a7(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x78f5
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_west
void mouse_resize_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[7]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_east();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_west_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7a07
xorps %xmm0, %xmm0
leaq 0x5b73(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x5f5(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x5ad0(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5f8f(%rip), %rax      # 0xd910
movl 0x1c(%rax), %eax
leaq 0x5abd(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5abb(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
movl 0x4(%rbx), %eax
leaq 0x60a5(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5f53(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x6094(%rip)      # 0xda84
addl 0x110(%rcx), %edx
movl %edx, 0x6094(%rip)      # 0xda90
leaq 0x9(%rip), %rax         # 0x7a0c
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_east
void mouse_resize_east(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[3]);
	
	mouse_resize_set_x_east((press_arg *)arg);

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_east_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7b10
xorps %xmm0, %xmm0
leaq 0x5a5c(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x4de(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x59b9(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5e78(%rip), %rax      # 0xd910
movl 0xc(%rax), %eax
leaq 0x59a6(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x59a4(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
leaq 0x5f91(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5e3f(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %eax
subl 0x4(%rbx), %eax
movl %eax, 0x5f7f(%rip)      # 0xda84
leaq 0x9(%rip), %rax         # 0x7b15
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north_west
void mouse_resize_north_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[0]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_y_north((press_arg *)arg);
	mouse_resize_set_east();
	mouse_resize_set_south();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_north_west_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7c43
xorps %xmm0, %xmm0
leaq 0x5953(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x3d5(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x58b0(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5d6f(%rip), %rax      # 0xd910
movl (%rax), %eax
leaq 0x589e(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x589c(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
movl 0x4(%rbx), %eax
leaq 0x5e86(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5d34(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x5e75(%rip)      # 0xda84
movl 0x8(%rbx), %eax
movl 0x10c(%rcx), %esi
subl %esi, %eax
movl %eax, 0x5e68(%rip)      # 0xda88
addl 0x110(%rcx), %edx
movl %edx, 0x5e64(%rip)      # 0xda90
addl 0x114(%rcx), %esi
movl %esi, 0x5e54(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x7c48
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north_east
void mouse_resize_north_east(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[2]);
	
	mouse_resize_set_x_east((press_arg *)arg);
	mouse_resize_set_y_north((press_arg *)arg);
	mouse_resize_set_south();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_north_east_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7d69
xorps %xmm0, %xmm0
leaq 0x5820(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x2a2(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x577d(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5c3c(%rip), %rax      # 0xd910
movl 0x8(%rax), %eax
leaq 0x576a(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5768(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
leaq 0x5d55(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5c03(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x5d43(%rip)      # 0xda84
movl 0x8(%rbx), %ecx
movl 0x10c(%rax), %edx
subl %edx, %ecx
movl %ecx, 0x5d36(%rip)      # 0xda88
addl 0x114(%rax), %edx
movl %edx, 0x5d2e(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x7d6e
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_south_west
void mouse_resize_south_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[6]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_y_south((press_arg *)arg);
	mouse_resize_set_east();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_south_west_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7531
testl %eax, %eax
je 0x7e8f
xorps %xmm0, %xmm0
leaq 0x56fa(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x17c(%rip), %rax       # 0x7f5e
movq %rax, 0x28(%r14)
leaq 0x5657(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5b16(%rip), %rax      # 0xd910
movl 0x18(%rax), %eax
leaq 0x5644(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5642(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movl (%rcx), %edx
subq $0x8, %rsp
movl $0x1, %esi
movl $0x2048, %ecx           # imm = 0x2048
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq %rax
pushq %rdx
callq 0x3160
addq $0x20, %rsp
movl 0x4(%rbx), %eax
leaq 0x5c2c(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5ada(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x5c1b(%rip)      # 0xda84
movl 0x114(%rcx), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x5c10(%rip)      # 0xda88
addl 0x110(%rcx), %edx
movl %edx, 0x5c0c(%rip)      # 0xda90
leaq 0x9(%rip), %rax         # 0x7e94
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_move_motion
static void mouse_move_motion(void *arg) {
	if (stack[curws].fwin->snap_index != SNAP_NONE) {
		return;
	}

	xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *)arg;
	xcb_query_pointer_reply_t *p = w_query_pointer();
	
	uint32_t vals[2];
	vals[0] = p->root_x - x;
	vals[1] = p->root_y - y;
	update_geometry(stack[curws].fwin, MOVE_MASK, vals);

	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5b86(%rip), %r14      # 0xda70
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5a34(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
cmpl $0x7, 0x178(%rax)
jne 0x7f53
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x10(%rax), %eax
subl 0x5b66(%rip), %eax      # 0xda84
leaq -0x20(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
subl 0x5b5a(%rip), %eax      # 0xda88
movl %eax, 0x4(%rdx)
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rdi
movl $0x3, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south_east
static void mouse_resize_motion_south_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_x + x;
	vals[1] = p->root_y + y;
	update_geometry(stack[curws].fwin, RESIZE_MASK, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x10(%rax), %eax
addl 0x5abd(%rip), %eax      # 0xda84
leaq -0x10(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
addl 0x5ab1(%rip), %eax      # 0xda88
movl %eax, 0x4(%rdx)
leaq 0x5a8f(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x593d(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xc, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south
static void mouse_resize_motion_south(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[1];
	vals[0] = p->root_y + y;
	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_HEIGHT, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x12(%rax), %eax
addl 0x5a5d(%rip), %eax      # 0xda88
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x5a38(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x58e6(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x8, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north
static void mouse_resize_motion_north(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_y - y;
	vals[1] = south - p->root_y + y;
	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x12(%rax), %eax
movl 0x5a06(%rip), %ecx      # 0xda88
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
subl %eax, %ecx
addl 0x59fa(%rip), %ecx      # 0xda8c
movl %esi, (%rdx)
movl %ecx, 0x4(%rdx)
leaq 0x59d2(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5880(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xa, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_west
static void mouse_resize_motion_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_x - x;
	vals[1] = east - p->root_x + x;	

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_WIDTH, vals);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x10(%rax), %eax
movl 0x599c(%rip), %ecx      # 0xda84
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
subl %eax, %ecx
addl 0x5998(%rip), %ecx      # 0xda90
movl %esi, (%rdx)
movl %ecx, 0x4(%rdx)
leaq 0x596c(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x581a(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x5, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_east
static void mouse_resize_motion_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[1];
	vals[0] = p->root_x + x;

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_WIDTH, vals);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x10(%rax), %eax
addl 0x5936(%rip), %eax      # 0xda84
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x5915(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x57c3(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x4, %esi
callq 0x5464
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north_west
static void mouse_resize_motion_north_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[4];
	vals[0] = p->root_x - x;
	vals[1] = p->root_y - y;
	vals[2] = east - p->root_x + x;	
	vals[3] = south - p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, MOVE_RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x37bc
movswl 0x10(%rax), %ecx
movl 0x58df(%rip), %edx      # 0xda84
movl %ecx, %esi
subl %edx, %esi
leaq -0x20(%rbp), %rbx
movl %esi, (%rbx)
movswl 0x12(%rax), %esi
movl 0x58cf(%rip), %edi      # 0xda88
movl %esi, %r8d
subl %edi, %r8d
movl %r8d, 0x4(%rbx)
subl %ecx, %edx
addl 0x58c5(%rip), %edx      # 0xda90
movl %edx, 0x8(%rbx)
subl %esi, %edi
addl 0x58b6(%rip), %edi      # 0xda8c
movl %edi, 0xc(%rbx)
movq %rax, %rdi
callq 0x3280
leaq 0x5888(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5736(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xf, %esi
movq %rbx, %rdx
callq 0x5464
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north_east
static void mouse_resize_motion_north_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[3];
	vals[0] = p->root_y - y;
	vals[1] = p->root_x + x;
	vals[2] = south - p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_Y | RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x37bc
movswl 0x12(%rax), %ecx
movl 0x585b(%rip), %edx      # 0xda88
movl %ecx, %esi
subl %edx, %esi
leaq -0x14(%rbp), %rbx
movl %esi, (%rbx)
movswl 0x10(%rax), %esi
addl 0x5843(%rip), %esi      # 0xda84
movl %esi, 0x4(%rbx)
subl %ecx, %edx
addl 0x5840(%rip), %edx      # 0xda8c
movl %edx, 0x8(%rbx)
movq %rax, %rdi
callq 0x3280
leaq 0x5812(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x56c0(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xe, %esi
movq %rbx, %rdx
callq 0x5464
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south_west
static void mouse_resize_motion_south_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[3];
	vals[0] = p->root_x - x;
	vals[1] = east - p->root_x + x;
	vals[2] = p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_X | RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x37bc
movswl 0x10(%rax), %ecx
movl 0x57e1(%rip), %edx      # 0xda84
movl %ecx, %esi
subl %edx, %esi
leaq -0x14(%rbp), %rbx
movl %esi, (%rbx)
subl %ecx, %edx
addl 0x57db(%rip), %edx      # 0xda90
movl %edx, 0x4(%rbx)
movswl 0x12(%rax), %ecx
addl 0x57c6(%rip), %ecx      # 0xda88
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
callq 0x3280
leaq 0x579c(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x564a(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xd, %esi
movq %rbx, %rdx
callq 0x5464
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop