LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/kaiserschmarrn0[P]mywm/workspace.c
// Function: print_stack
void print_stack(int ws, int type) {
	printf("workspace %x [fwin: %x]: ", ws, stack[ws].fwin ? stack[ws].fwin->windows[WIN_CHILD] : 0);
	for (window *list = stack[ws].lists[type].first; list; list = list->next[ws][type]) {
		printf("win %x -> ", list->windows[WIN_CHILD]);
	}
	printf("NULL\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %esi
movslq %edi, %r14
leaq (%r14,%r14,4), %rax
shlq $0x4, %rax
leaq 0x73e7(%rip), %rcx      # 0xd930
leaq (%rcx,%rax), %r12
movq 0x48(%rax,%rcx), %rax
testq %rax, %rax
je 0x655f
movl 0xcc(%rax), %edx
jmp 0x6561
xorl %edx, %edx
leaq 0x2c5f(%rip), %rdi      # 0x91c7
xorl %eax, %eax
callq 0x3060
movslq %ebx, %r15
leaq (%r15,%r15,2), %rax
movq (%r12,%rax,8), %r12
testq %r12, %r12
je 0x65a9
leaq 0x2c5b(%rip), %rbx      # 0x91e1
leaq (%r14,%r14,2), %r14
movl 0xcc(%r12), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3060
leaq (%r12,%r14,8), %rax
movq (%rax,%r15,8), %r12
testq %r12, %r12
jne 0x658a
leaq 0x2c66(%rip), %rdi      # 0x9216
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O3/kaiserschmarrn0[P]mywm/workspace.c
// Function: safe_traverse
void safe_traverse(int ws, int type, void (*func)(window *)) {
	for (window *list = stack[ws].lists[type].first; list;) {
		window *temp = list->next[ws][type];
		func(list);
		list = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movslq %edi, %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x72dd(%rip), %rdx      # 0xd930
addq %rcx, %rdx
movslq %esi, %r14
leaq (%r14,%r14,2), %rcx
movq (%rdx,%rcx,8), %rdi
testq %rdi, %rdi
je 0x667c
leaq (%rax,%rax,2), %r15
leaq (%rdi,%r15,8), %rax
movq (%rax,%r14,8), %r12
callq *%rbx
movq %r12, %rdi
testq %r12, %r12
jne 0x666a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7288(%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 0x6733
movq %rbx, %rdi
callq 0x4f44
movq 0x18(%r15), %rax
movq %rax, 0x8(%rbx,%r12)
movq $0x0, 0x8(%r13,%r12)
movq 0x18(%r15), %rax
leaq 0x20(%r15), %rcx
testq %rax, %rax
leaq 0x68(%rax,%r12), %rax
cmoveq %rcx, %rax
movq %rbx, (%rax)
movq %rbx, 0x18(%r15)
incl 0x28(%r15)
jmp 0x673b
movq %rbx, %rdi
callq 0x4f12
cmpl $0x0, 0xc4(%rbx)
je 0x6777
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 0x67a8
cmpl $0x0, 0x18c(%rbx)
jne 0x67a8
cmpl $0x0, 0x190(%rbx)
jne 0x67a8
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x67a8
leaq (%r14,%r14,2), %rbx
movq 0x10(%rdi,%rbx,8), %r14
callq 0x4f76
movq %r14, %rdi
testq %r14, %r14
jne 0x6796
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7159(%rip), %rdx      # 0xd930
leaq (%rdx,%rcx), %r14
movq 0x8(%rcx,%rdx), %rsi
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq %rsi, 0x60(%rbx,%r15)
movq $0x0, (%rbx,%r15)
movq 0x8(%rcx,%rdx), %rax
leaq (%rax,%r15), %rsi
testq %rax, %rax
cmoveq %r14, %rsi
movq %rbx, (%rsi)
movq %rbx, 0x8(%rcx,%rdx)
incl 0x10(%rcx,%rdx)
cmpl $0x0, 0xc0(%rbx)
je 0x6859
leaq 0x60(%rbx), %r12
movq %rbx, %rdi
callq 0x4ee0
leaq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
movq %rcx, 0x8(%r12,%r15)
movq $0x0, 0x8(%rbx,%r15)
movq 0x20(%r14), %rcx
testq %rcx, %rcx
leaq 0x8(%rcx,%r15), %rcx
cmoveq %rax, %rcx
movq %rbx, (%rcx)
movq %rbx, 0x20(%r14)
incl 0x28(%r14)
jmp 0x6861
movq %rbx, %rdi
callq 0x4eae
cmpl $0x0, 0xc4(%rbx)
jne 0x6873
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3694
jmp 0x686a
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $0x0, 0xc0(%rsi)
movslq %edi, %rax
je 0x68df
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rsi,%rcx), %rdx
leaq (%rax,%rax,4), %rdi
shlq $0x4, %rdi
testq %rdx, %rdx
leaq 0x7083(%rip), %r8       # 0xd930
leaq 0x20(%rdi,%r8), %r9
leaq 0x68(%rdx,%rcx), %rdx
cmoveq %r9, %rdx
movq 0x68(%rsi,%rcx), %r9
movq %r9, (%rdx)
testq %r9, %r9
movq 0x8(%rsi,%rcx), %rdx
leaq 0x18(%rdi,%r8), %rdi
leaq 0x8(%r9,%rcx), %rcx
cmoveq %rdi, %rcx
movq %rdx, (%rcx)
decl 0x10(%rdi)
cmpl $0x0, 0xc4(%rsi)
je 0x693d
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rsi,%rcx), %rdx
leaq (%rax,%rax,4), %rdi
shlq $0x4, %rdi
testq %rdx, %rdx
leaq 0x7025(%rip), %r8       # 0xd930
leaq 0x38(%rdi,%r8), %r9
leaq 0x70(%rdx,%rcx), %rdx
cmoveq %r9, %rdx
movq 0x70(%rsi,%rcx), %r9
movq %r9, (%rdx)
testq %r9, %r9
movq 0x10(%rsi,%rcx), %rdx
leaq 0x30(%rdi,%r8), %rdi
leaq 0x10(%r9,%rcx), %rcx
cmoveq %rdi, %rcx
movq %rdx, (%rcx)
decl 0x10(%rdi)
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rsi,%rcx), %rdx
movq 0x60(%rsi,%rcx), %rdi
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6fcf(%rip), %r8       # 0xd930
leaq (%r8,%rax), %r9
testq %rdx, %rdx
leaq 0x8(%rax,%r8), %rax
leaq 0x60(%rdx,%rcx), %rdx
cmoveq %rax, %rdx
movq %rdi, (%rdx)
leaq (%rdi,%rcx), %rdx
testq %rdi, %rdi
movq (%rsi,%rcx), %rcx
cmoveq %r9, %rdx
movq %rcx, (%rdx)
decl 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movslq %edi, %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x6ecc(%rip), %rdx      # 0xd930
addq %rcx, %rdx
movslq %esi, %r12
leaq (%r12,%r12,2), %rcx
movq (%rdx,%rcx,8), %r14
testq %r14, %r14
je 0x6a9b
leaq (%rax,%rax,2), %r13
movq %r14, %rdi
movl %r15d, %esi
callq *%rbx
movl %eax, %edx
testl %eax, %eax
jns 0x6a9e
leaq (%r14,%r13,8), %rax
movq (%rax,%r12,8), %r14
testq %r14, %r14
jne 0x6a7b
xorl %r14d, %r14d
jmp 0x6a9e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq %edi, %r11
leaq (%r11,%r11,4), %rax
shlq $0x4, %rax
leaq 0x6e6e(%rip), %r9       # 0xd930
addq %rax, %r9
movslq %esi, %rdi
leaq (%rdi,%rdi,2), %rax
movq (%r9,%rax,8), %rax
testq %rax, %rax
je 0x6b0e
pushq %rbp
movq %rsp, %rbp
movslq %edx, %r9
movslq %ecx, %r10
leaq (%r11,%r11,2), %r11
cmpl %ecx, %edx
jge 0x6afc
movq %r9, %rsi
cmpl %r8d, 0xcc(%rax,%rsi,4)
je 0x6b0b
incq %rsi
cmpq %rsi, %r10
jne 0x6aea
leaq (%rax,%r11,8), %rax
movq (%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x6ae3
xorl %eax, %eax
popq %rbp
jmp 0x6b10
xorl %eax, %eax
movl %esi, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6e0b(%rip), %r8       # 0xd930
addq %rax, %r8
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rax
movq (%r8,%rax,8), %rax
testq %rax, %rax
je 0x6b5d
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rdx
leaq (%rdi,%rdi,2), %rdi
cmpl %ecx, 0xcc(%rax,%rdx,4)
je 0x6b5b
leaq (%rax,%rdi,8), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x6b43
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6dbe(%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 0x6ba7
leaq (%rdx,%rdx,2), %r10
cmpl %ecx, 0xcc(%rax,%r9,4)
je 0x6bb4
leaq (%rax,%r10,8), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x6b90
incq %rdx
cmpq $0x4, %rdx
jne 0x6b7b
xorl %eax, %eax
jmp 0x6bbb
testq %rdi, %rdi
je 0x6bbb
movl %edx, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6d5d(%rip), %rcx      # 0xd930
movq 0x18(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x6be3
popq %rbp
jmp 0x5181
leaq 0x685e(%rip), %rax      # 0xd448
movq (%rax), %rdi
leaq 0x685c(%rip), %rax      # 0xd450
movq (%rax), %rax
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
popq %rbp
jmp 0x3150
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x6e28(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6cd6(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rax
testq %rax, %rax
je 0x6cd1
leaq 0x67dd(%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 0x579d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x675d(%rip), %rax      # 0xd444
movl $0x0, (%rax)
leaq -0x3452(%rip), %rax     # 0x38a2
leaq 0x67d5(%rip), %rcx      # 0xd4d0
movq %rax, 0x38(%rcx)
leaq -0x33b1(%rip), %rax     # 0x3955
movq %rax, 0x40(%rcx)
leaq 0x6d5f(%rip), %rax      # 0xda70
movl (%rax), %edi
leaq -0x1f79(%rip), %rdx     # 0x4da1
movl $0x1, %esi
callq 0x65e1
leaq 0x14(%rip), %rax        # 0x6d3f
movq %rax, 0x661e(%rip)      # 0xd350
movq 0x6d3f(%rip), %rdi      # 0xda78
popq %rbp
jmp 0x3280
// File: /workspace/github_c_makefile_star2_O3/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 0x66f0(%rip), %rax      # 0xd444
movl $0x3, (%rax)
xorps %xmm0, %xmm0
leaq 0x676c(%rip), %rax      # 0xd4d0
movups %xmm0, 0x38(%rax)
leaq 0x6d01(%rip), %rbx      # 0xda70
movl (%rbx), %edi
leaq -0x200c(%rip), %rdx     # 0x4d6c
movl $0x1, %esi
callq 0x65e1
movslq (%rbx), %r14
leaq (%r14,%r14,4), %r15
shlq $0x4, %r15
leaq 0x6b9c(%rip), %r12      # 0xd930
movslq 0x28(%r12,%r15), %rbx
testq %rbx, %rbx
setg %r13b
leaq (,%rbx,8), %rdi
callq 0x3170
movq %rax, 0x6cc4(%rip)      # 0xda78
movq 0x18(%r12,%r15), %rcx
testq %rcx, %rcx
setne %dl
andb %r13b, %dl
cmpb $0x1, %dl
jne 0x6df3
movq 0x48(%r12,%r15), %rdx
xorl %esi, %esi
leaq (%r14,%r14,2), %rdi
cmpq %rdx, %rcx
jne 0x6ddd
movl %esi, 0x6ca3(%rip)      # 0xda80
movq %rcx, (%rax,%rsi,8)
incq %rsi
cmpq %rbx, %rsi
jge 0x6df3
movq 0x8(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x6dd2
leaq 0x519(%rip), %rax       # 0x7313
movq %rax, 0x654f(%rip)      # 0xd350
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7313
// File: /workspace/github_c_makefile_star2_O3/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 0x6c51(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq 0x6aff(%rip), %rdx      # 0xd930
movq 0x18(%rdx,%rcx), %rcx
testq %rcx, %rcx
je 0x6e4e
leaq (%rax,%rax,2), %rax
cmpq $0x0, 0x8(%rcx,%rax,8)
je 0x6e4e
popq %rbp
jmpq *0x6502(%rip)           # 0xd350
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23b7(%rip), %rdi      # 0x921b
movl %ebx, %esi
xorl %eax, %eax
callq 0x3060
leaq 0x6bfc(%rip), %r14      # 0xda70
movl (%r14), %edi
cmpl %edi, %ebx
jne 0x6e84
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq %ebx, %r15
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6a97(%rip), %r12      # 0xd930
movq 0x48(%r12,%rax), %rax
testq %rax, %rax
je 0x6eae
movq %rax, %rdi
callq 0x5011
movl (%r14), %edi
leaq -0x1bb1(%rip), %rdx     # 0x5304
movl $0x1, %esi
callq 0x65e1
leaq 0x6592(%rip), %rax      # 0xd458
movq (%rax), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x3540
leaq -0x1c18(%rip), %rdx     # 0x52c1
movl %ebx, %edi
movl $0x1, %esi
callq 0x65e1
movl %ebx, (%r14)
leaq (%r15,%r15,4), %rax
shlq $0x4, %rax
movq 0x48(%r12,%rax), %rdi
testq %rdi, %rdi
je 0x6f07
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5181
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6bbd
// File: /workspace/github_c_makefile_star2_O3/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 0x6b47(%rip), %r14      # 0xda70
movl (%r14), %eax
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rax
shlq $0x4, %rax
leaq 0x69f2(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
testq %rax, %rax
sete %dl
cmpl %ecx, %ebx
sete %cl
orb %dl, %cl
jne 0x6f5b
cmpl $0x0, 0xc8(%rax)
je 0x6f66
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, 0x194(%rax)
leaq 0x64d1(%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 0x687a
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rsi
movl %ebx, %edi
callq 0x6685
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 0x6bbd
// File: /workspace/github_c_makefile_star2_O3/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 0x6a16(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x68c4(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rdi
testq %rdi, %rdi
je 0x7092
movl 0x18c(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0x18c(%rdi)
cmpl $0x0, 0x190(%rdi)
je 0x7097
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
je 0x70a4
popq %rbx
popq %r14
popq %rbp
jmp 0x5468
callq 0x543a
movslq (%rbx), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r14,%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5699
// File: /workspace/github_c_makefile_star2_O3/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 0x6859(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b13
testq %rax, %rax
je 0x728d
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x728d
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x66e0(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x728d
cmpl $0x0, 0x164(%rbx)
jne 0x728d
movl 0x114(%rbx), %eax
movl %eax, 0x160(%rbx)
leaq -0x14(%rbp), %rdx
movl $0x20, (%rdx)
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5498
movl $0x1, 0x164(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x67cc(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b13
testq %rax, %rax
je 0x730e
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x730e
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6653(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x730e
cmpl $0x0, 0x164(%rbx)
je 0x730e
movq %rbx, %rdx
addq $0x160, %rdx            # imm = 0x160
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5498
movl $0x0, 0x164(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6760(%rip), %rbx      # 0xda80
testq %rbx, %rbx
js 0x7341
movq 0x674c(%rip), %rax      # 0xda78
movq (%rax,%rbx,8), %rdi
callq 0x4f76
addq $-0x1, %rbx
jb 0x7325
movl 0x673f(%rip), %ebx      # 0xda80
incl %ebx
leaq 0x6726(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x65d4(%rip), %rcx      # 0xd930
xorl %edx, %edx
cmpl 0x28(%rcx,%rax), %ebx
cmovbl %ebx, %edx
movl %edx, 0x6715(%rip)      # 0xda80
movq 0x6706(%rip), %rax      # 0xda78
movq (%rax,%rdx,8), %rbx
movq %rbx, %rdi
callq 0x4f76
movq %rbx, %rdi
callq 0x4e0b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5181
// File: /workspace/github_c_makefile_star2_O3/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 0x876a
leaq 0x60a2(%rip), %rax      # 0xd448
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3050
leaq 0x608d(%rip), %rax      # 0xd444
movl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x6109(%rip), %rax      # 0xd4d0
movups %xmm0, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x747d
leaq 0x177(%rip), %rax       # 0x75a3
leaq 0x609d(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
leaq -0xaa(%rip), %rax       # 0x7394
movq %rax, 0x28(%rcx)
leaq 0x6627(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x64d5(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
cmpl $0x7, 0x178(%rdi)
jne 0x7486
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
subl 0x108(%rdi), %ecx
subl 0x10c(%rdi), %eax
jmp 0x74ba
addq $0x8, %rsp
jmp 0x7518
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %esi
subl 0x108(%rdi), %eax
imull 0x170(%rdi), %eax
xorl %edx, %edx
divl 0x110(%rdi)
movl %eax, %ecx
subl 0x10c(%rdi), %esi
imull 0x174(%rdi), %esi
movl %esi, %eax
xorl %edx, %edx
divl 0x114(%rdi)
movl %ecx, 0x65c4(%rip)      # 0xda84
movl %eax, 0x65c2(%rip)      # 0xda88
leaq 0x5f77(%rip), %rax      # 0xd444
movl $0x1, (%rax)
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x870c
leaq 0x5f65(%rip), %rax      # 0xd448
movq (%rax), %rdi
leaq 0x5f63(%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_O3/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 0x6542(%rip), %r14      # 0xda70
movl (%r14), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6b13
xorl %ebx, %ebx
testq %rax, %rax
je 0x7596
cmpl $0x0, 0xc0(%rax)
je 0x7596
movslq (%r14), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x63ce(%rip), %r15      # 0xd930
movq 0x48(%r15,%rcx), %rdi
cmpq %rdi, %rax
jne 0x7596
callq 0x4fcc
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r15,%rax), %rax
cmpl $0x0, 0x190(%rax)
jne 0x7596
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_O3/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 0x64c2(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x6370(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
cmpl $0x7, 0x178(%rdi)
je 0x75d3
callq 0x83a7
callq 0x7ec3
leaq 0x8e4(%rip), %rax       # 0x7ec3
leaq 0x5eea(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x76ba
xorps %xmm0, %xmm0
leaq 0x5ec1(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x92d(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x5e1e(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x62dd(%rip), %rax      # 0xd910
movl 0x10(%rax), %eax
leaq 0x5e0b(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5e09(%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 0x63f6(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x62a4(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x63e4(%rip)      # 0xda84
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x63d9(%rip)      # 0xda88
leaq 0x9(%rip), %rax         # 0x76bf
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x77c3
xorps %xmm0, %xmm0
leaq 0x5da9(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x815(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x5d06(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x61c5(%rip), %rax      # 0xd910
movl 0x14(%rax), %eax
leaq 0x5cf3(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5cf1(%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 0x62de(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x618c(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x62d0(%rip)      # 0xda88
leaq 0x9(%rip), %rax         # 0x77c8
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x78da
xorps %xmm0, %xmm0
leaq 0x5ca0(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x70c(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x5bfd(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x60bc(%rip), %rax      # 0xd910
movl 0x4(%rax), %eax
leaq 0x5bea(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5be8(%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 0x61d2(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x6080(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x10c(%rcx), %edx
subl %edx, %eax
movl %eax, 0x61c5(%rip)      # 0xda88
addl 0x114(%rcx), %edx
movl %edx, 0x61bd(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x78df
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x79f1
xorps %xmm0, %xmm0
leaq 0x5b89(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x5f5(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x5ae6(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5fa5(%rip), %rax      # 0xd910
movl 0x1c(%rax), %eax
leaq 0x5ad3(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5ad1(%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 0x60bb(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5f69(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x60aa(%rip)      # 0xda84
addl 0x110(%rcx), %edx
movl %edx, 0x60aa(%rip)      # 0xda90
leaq 0x9(%rip), %rax         # 0x79f6
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x7afa
xorps %xmm0, %xmm0
leaq 0x5a72(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x4de(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x59cf(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5e8e(%rip), %rax      # 0xd910
movl 0xc(%rax), %eax
leaq 0x59bc(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x59ba(%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 0x5fa7(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5e55(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %eax
subl 0x4(%rbx), %eax
movl %eax, 0x5f95(%rip)      # 0xda84
leaq 0x9(%rip), %rax         # 0x7aff
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x7c2d
xorps %xmm0, %xmm0
leaq 0x5969(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x3d5(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x58c6(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5d85(%rip), %rax      # 0xd910
movl (%rax), %eax
leaq 0x58b4(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x58b2(%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 0x5e9c(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5d4a(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x5e8b(%rip)      # 0xda84
movl 0x8(%rbx), %eax
movl 0x10c(%rcx), %esi
subl %esi, %eax
movl %eax, 0x5e7e(%rip)      # 0xda88
addl 0x110(%rcx), %edx
movl %edx, 0x5e7a(%rip)      # 0xda90
addl 0x114(%rcx), %esi
movl %esi, 0x5e6a(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x7c32
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x7d53
xorps %xmm0, %xmm0
leaq 0x5836(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x2a2(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x5793(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5c52(%rip), %rax      # 0xd910
movl 0x8(%rax), %eax
leaq 0x5780(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x577e(%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 0x5d6b(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5c19(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x5d59(%rip)      # 0xda84
movl 0x8(%rbx), %ecx
movl 0x10c(%rax), %edx
subl %edx, %ecx
movl %ecx, 0x5d4c(%rip)      # 0xda88
addl 0x114(%rax), %edx
movl %edx, 0x5d44(%rip)      # 0xda8c
leaq 0x9(%rip), %rax         # 0x7d58
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751b
testl %eax, %eax
je 0x7e79
xorps %xmm0, %xmm0
leaq 0x5710(%rip), %r14      # 0xd4d0
movups %xmm0, 0x38(%r14)
leaq 0x17c(%rip), %rax       # 0x7f48
movq %rax, 0x28(%r14)
leaq 0x566d(%rip), %rax      # 0xd444
movl $0x2, (%rax)
leaq 0x5b2c(%rip), %rax      # 0xd910
movl 0x18(%rax), %eax
leaq 0x565a(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
leaq 0x5658(%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 0x5c42(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq 0x5af0(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
movl 0x108(%rcx), %edx
subl %edx, %eax
movl %eax, 0x5c31(%rip)      # 0xda84
movl 0x114(%rcx), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x5c26(%rip)      # 0xda88
addl 0x110(%rcx), %edx
movl %edx, 0x5c22(%rip)      # 0xda90
leaq 0x9(%rip), %rax         # 0x7e7e
movq %rax, 0x30(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b9c(%rip), %r14      # 0xda70
movslq (%r14), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5a4a(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
cmpl $0x7, 0x178(%rax)
jne 0x7f3d
xorl %eax, %eax
callq 0x37bc
movq %rax, %rbx
movswl 0x10(%rax), %eax
subl 0x5b7c(%rip), %eax      # 0xda84
leaq -0x20(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
subl 0x5b70(%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 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5ad3(%rip), %eax      # 0xda84
leaq -0x10(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
addl 0x5ac7(%rip), %eax      # 0xda88
movl %eax, 0x4(%rdx)
leaq 0x5aa5(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5953(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xc, %esi
callq 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a73(%rip), %eax      # 0xda88
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x5a4e(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x58fc(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x8, %esi
callq 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a1c(%rip), %ecx      # 0xda88
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
subl %eax, %ecx
addl 0x5a10(%rip), %ecx      # 0xda8c
movl %esi, (%rdx)
movl %ecx, 0x4(%rdx)
leaq 0x59e8(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5896(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xa, %esi
callq 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x59b2(%rip), %ecx      # 0xda84
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
subl %eax, %ecx
addl 0x59ae(%rip), %ecx      # 0xda90
movl %esi, (%rdx)
movl %ecx, 0x4(%rdx)
leaq 0x5982(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5830(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x5, %esi
callq 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x594c(%rip), %eax      # 0xda84
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x592b(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x57d9(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0x4, %esi
callq 0x5498
movq %rbx, %rdi
callq 0x3280
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58f5(%rip), %edx      # 0xda84
movl %ecx, %esi
subl %edx, %esi
leaq -0x20(%rbp), %rbx
movl %esi, (%rbx)
movswl 0x12(%rax), %esi
movl 0x58e5(%rip), %edi      # 0xda88
movl %esi, %r8d
subl %edi, %r8d
movl %r8d, 0x4(%rbx)
subl %ecx, %edx
addl 0x58db(%rip), %edx      # 0xda90
movl %edx, 0x8(%rbx)
subl %esi, %edi
addl 0x58cc(%rip), %edi      # 0xda8c
movl %edi, 0xc(%rbx)
movq %rax, %rdi
callq 0x3280
leaq 0x589e(%rip), %rax      # 0xda70
movslq (%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x574c(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
movl $0xf, %esi
movq %rbx, %rdx
callq 0x5498
addq $0x18, %rsp
popq %rbx
popq %rbp
retq