LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/window.c
// Function: create_window_existing
void create_window_existing(xcb_window_t child) {
	window *win = allocate_window(child);

	xcb_get_geometry_reply_t *geom = w_get_geometry(child);
	uint32_t w = size_helper(geom->width + 2 * PAD, scr->width_in_pixels);
	uint32_t h = size_helper(geom->height + PAD_N + PAD, scr->height_in_pixels - TOP - BOT);
	uint32_t x = create_window_existing_place_helper(geom->x - PAD, w, scr->width_in_pixels);
	uint32_t y = TOP + create_window_existing_place_helper(geom->y - TOP - PAD_N, h, scr->height_in_pixels - TOP - BOT);
	free(geom);

	create_window(win, x, y, w, h);
	win->ignore_unmap = 1;
	
	insert_into(curws, win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x6fa0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x70b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %edi
addl $0x2, %edi
leaq 0x89db(%rip), %rax      # 0x10450
movq (%rax), %rax
movzwl 0x14(%rax), %esi
callq 0x70f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %edi
addl $0x20, %edi
addl $0x1, %edi
leaq 0x89b7(%rip), %rax      # 0x10450
movq (%rax), %rax
movzwl 0x16(%rax), %esi
subl $0x0, %esi
subl $0x0, %esi
callq 0x70f0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movswl 0xc(%rax), %edi
subl $0x1, %edi
movl -0x1c(%rbp), %esi
leaq 0x898d(%rip), %rax      # 0x10450
movq (%rax), %rax
movzwl 0x14(%rax), %edx
callq 0x7b50
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movswl 0xe(%rax), %edi
subl $0x0, %edi
subl $0x20, %edi
movl -0x20(%rbp), %esi
leaq 0x8966(%rip), %rax      # 0x10450
movq (%rax), %rax
movzwl 0x16(%rax), %edx
subl $0x0, %edx
subl $0x0, %edx
callq 0x7b50
addl $0x0, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3270
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0x7180
movq -0x10(%rbp), %rax
movl $0x1, 0x194(%rax)
leaq 0x8f3a(%rip), %rax      # 0x10a70
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x7f90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/window.c
// Function: create_window_existing_place_helper
static uint32_t create_window_existing_place_helper(int start, uint32_t win_sze, uint32_t scr_sze) {
	if (start < 0) {
		return 0;
	} else if (start + win_sze > scr_sze) {
		return scr_sze - win_sze;
	}

	return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x7b6c
movl $0x0, -0x4(%rbp)
jmp 0x7b8a
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jbe 0x7b82
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b8a
jmp 0x7b84
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/window.c
// Function: window_property_helper
static void window_property_helper(xcb_get_property_cookie_t cookie, window *win, 
		void (*func)(window *, xcb_ewmh_get_atoms_reply_t, int)) {
	xcb_ewmh_get_atoms_reply_t type;
	if (!xcb_ewmh_get_wm_window_type_reply(ewmh, cookie, &type, NULL)) {
		return;
	}
	
	for (int i = 0; i < type.atoms_len; i++) {
		func(win, type, i);
	}
		
	xcb_ewmh_get_atoms_reply_wipe(&type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x88ae(%rip), %rax      # 0x10458
movq (%rax), %rdi
movl -0x4(%rbp), %esi
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3110
cmpb $0x0, %al
jne 0x7bc3
jmp 0x7c10
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x7c07
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
leaq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
callq *%rax
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7bca
leaq -0x30(%rbp), %rdi
callq 0x3620
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/window.c
// Function: test_window_type
static void test_window_type(window *win, xcb_ewmh_get_atoms_reply_t type, int i) {
	if (type.atoms[i] != ewmh->_NET_WM_WINDOW_TYPE_DOCK 
			&& type.atoms[i] != ewmh->_NET_WM_WINDOW_TYPE_TOOLBAR
			&& type.atoms[i] != ewmh->_NET_WM_WINDOW_TYPE_DESKTOP) {
		return;
	}

	win->normal = 0;

	uint32_t mask = XCB_CW_EVENT_MASK;
	uint32_t val = XCB_EVENT_MASK_STRUCTURE_NOTIFY;
	xcb_change_window_attributes(conn, win->windows[WIN_CHILD], mask, &val);

	xcb_map_window(conn, win->windows[WIN_CHILD]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x880f(%rip), %rcx      # 0x10458
movq (%rcx), %rcx
cmpl 0xd4(%rcx), %eax
je 0x7c98
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x87ee(%rip), %rcx      # 0x10458
movq (%rcx), %rcx
cmpl 0xd8(%rcx), %eax
je 0x7c98
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x87cd(%rip), %rcx      # 0x10458
movq (%rcx), %rcx
cmpl 0xd0(%rcx), %eax
je 0x7c98
jmp 0x7cf3
movq -0x8(%rbp), %rax
movl $0x0, 0xc0(%rax)
movl $0x800, -0x10(%rbp)     # imm = 0x800
movl $0x20000, -0x14(%rbp)   # imm = 0x20000
leaq 0x878d(%rip), %rax      # 0x10448
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %esi
movl -0x10(%rbp), %edx
leaq -0x14(%rbp), %rcx
callq 0x33a0
movl %eax, -0x18(%rbp)
leaq 0x876a(%rip), %rax      # 0x10448
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %esi
callq 0x3230
movl %eax, -0x1c(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/window.c
// Function: test_window_state
static void test_window_state(window *win, xcb_ewmh_get_atoms_reply_t type, int i) {
	if (type.atoms[i] == ewmh->_NET_WM_STATE_STICKY) {
		stick_helper(win);
	}
	if (type.atoms[i] == ewmh->_NET_WM_STATE_ABOVE) {
		win->above = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x872f(%rip), %rcx      # 0x10458
movq (%rcx), %rcx
cmpl 0x10c(%rcx), %eax
jne 0x7d3d
movq -0x8(%rbp), %rdi
callq 0x62c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x8705(%rip), %rcx      # 0x10458
movq (%rcx), %rcx
cmpl 0x12c(%rcx), %eax
jne 0x7d6c
movq -0x8(%rbp), %rax
movl $0x1, 0xc4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x8b91(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x7dce
movslq -0x4(%rbp), %rcx
leaq 0x8b78(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl 0xcc(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x7dd5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x7dd5
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0x43b5(%rip), %rdi      # 0xc197
movb $0x0, %al
callq 0x3060
movslq -0x4(%rbp), %rcx
leaq 0x8b3c(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e49
movq -0x10(%rbp), %rax
movl 0xcc(%rax), %esi
leaq 0x438c(%rip), %rdi      # 0xc1b1
movb $0x0, %al
callq 0x3060
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x7e0d
leaq 0x436c(%rip), %rdi      # 0xc1bc
movb $0x0, %al
callq 0x3060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x8a03(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f7c
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x7f46
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x8040
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x7fd6
movq -0x10(%rbp), %rdi
callq 0x5c50
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x8040
jmp 0x7fdf
movq -0x10(%rbp), %rdi
callq 0x5c20
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
je 0x7fff
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x8040
jmp 0x802f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18c(%rax)
jne 0x802d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jne 0x802d
movl -0x4(%rbp), %edi
movl $0x2, %esi
leaq -0x23a8(%rip), %rdx     # 0x5c80
callq 0x7f10
jmp 0x802f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/workspace.c
// Function: insert_into_helper
static void insert_into_helper(int ws, int type, window *win) {
	win->next[ws][type] = stack[ws].lists[type].first;
	win->prev[ws][type] = NULL;

	if (stack[ws].lists[type].first) {
		stack[ws].lists[type].first->prev[ws][type] = win;
	} else {
		stack[ws].lists[type].last = win;
	}

	stack[ws].lists[type].first = win;
	
	stack[ws].lists[type].count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x88d7(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x8881(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x8104
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x885a(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x8129
movq -0x10(%rbp), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x881d(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x87f8(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x87d8(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x8200
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x81c6
movq -0x10(%rbp), %rdi
callq 0x5bf0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x8200
jmp 0x81cf
movq -0x10(%rbp), %rdi
callq 0x5bc0
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
je 0x81f6
movq 0x7e05(%rip), %rax      # 0xffe8
movq (%rax), %rdi
leaq 0x3fd5(%rip), %rsi      # 0xc1c2
movb $0x0, %al
callq 0x35c0
jmp 0x81f8
jmp 0x81f8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/workspace.c
// Function: append_to_helper
static void append_to_helper(int ws, int type, window *win) {
	win->prev[ws][type] = stack[ws].lists[type].last;
	win->next[ws][type] = NULL;

	if (stack[ws].lists[type].last) {
		stack[ws].lists[type].last->next[ws][type] = win;
	} else {
		stack[ws].lists[type].first = win;
	}

	stack[ws].lists[type].last = win;
	
	stack[ws].lists[type].count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x8717(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x86c0(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x82c3
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x8698(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x82e7
movq -0x10(%rbp), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x865e(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x863a(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8619(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x836d
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x83a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
je 0x838b
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x83a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x83a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8413
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x844f
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x84f7(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x84b4
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x84eb
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x845a(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x843a(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/workspace.c
// Function: all_but_helper
static void all_but_helper(int ws, window *win, void (*func)(int, window *)) {
	int i;
	for (i = 0; i < ws; i++) {
		func(i, win);
	}

	for (i++; i < NUM_WS; i++) {
		func(i, win);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x858a
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x856a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x85b1
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8593
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x8320(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x866b
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq *%rax
movl %eax, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jge 0x864c
jmp 0x866d
jmp 0x864e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x8629
jmp 0x866d
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x8291(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8715
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x86f6
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl 0xcc(%rax,%rcx,4), %eax
cmpl -0x24(%rbp), %eax
jne 0x86e9
movl -0x28(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x8717
jmp 0x86eb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x86c5
jmp 0x86f8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x86b8
jmp 0x8717
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x81f5(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8790
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xcc(%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jne 0x8771
jmp 0x8790
jmp 0x8773
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x8754
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x87fd
movl -0x24(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x8720
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x87f0
cmpq $0x0, -0x8(%rbp)
je 0x87ee
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x87fd
jmp 0x87f2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x87bc
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x810a(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8863
leaq 0x7c05(%rip), %rax      # 0x10448
movq (%rax), %rdi
leaq 0x7c03(%rip), %rax      # 0x10450
movq (%rax), %rax
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x3140
movl %eax, -0x14(%rbp)
jmp 0x886c
movq -0x10(%rbp), %rdi
callq 0x5f60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x817d(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x8033(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
jne 0x8910
jmp 0x89c9
leaq 0x7b31(%rip), %rax      # 0x10448
movq (%rax), %rdi
leaq 0x814f(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x8005(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl 0xd0(%rax), %esi
callq 0x3560
movl %eax, -0xc(%rbp)
leaq 0x7afd(%rip), %rax      # 0x10448
movq (%rax), %rdi
leaq 0x811b(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7fd1(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl 0xcc(%rax), %esi
callq 0x3560
movl %eax, -0x10(%rbp)
leaq 0x80f1(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7fa7(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl 0xcc(%rax), %edi
callq 0x3780
leaq 0x80ca(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7f80(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq 0x80ae(%rip), %rax      # 0x10a70
movl (%rax), %esi
callq 0x6810
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x7a69(%rip), %rax      # 0x10444
movl $0x0, (%rax)
leaq 0x7ae8(%rip), %rax      # 0x104d0
leaq -0x515f(%rip), %rcx     # 0x3890
movq %rcx, 0x38(%rax)
leaq 0x7ad6(%rip), %rax      # 0x104d0
leaq -0x5091(%rip), %rcx     # 0x3970
movq %rcx, 0x40(%rax)
leaq 0x8064(%rip), %rax      # 0x10a70
movl (%rax), %edi
movl $0x1, %esi
leaq -0x2ffa(%rip), %rdx     # 0x5a20
callq 0x7ea0
leaq 0x1a(%rip), %rax        # 0x8a40
movq %rax, 0x792b(%rip)      # 0x10358
movq 0x8044(%rip), %rdi      # 0x10a78
callq 0x3270
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
leaq 0x79f5(%rip), %rax      # 0x10444
movl $0x3, (%rax)
leaq 0x7a74(%rip), %rax      # 0x104d0
movq $0x0, 0x38(%rax)
leaq 0x7a65(%rip), %rax      # 0x104d0
movq $0x0, 0x40(%rax)
leaq 0x7ff6(%rip), %rax      # 0x10a70
movl (%rax), %edi
movl $0x1, %esi
leaq -0x30b8(%rip), %rdx     # 0x59d0
callq 0x7ea0
leaq 0x7fdc(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7e92(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3160
movq %rax, 0x7fb9(%rip)      # 0x10a78
leaq 0x7faa(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7e60(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x15(%rbp)
jge 0x8afe
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x8b07
jmp 0x8b70
movq -0x10(%rbp), %rax
leaq 0x7f5e(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x7e14(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
jne 0x8b32
movl -0x14(%rbp), %eax
movl %eax, 0x7f4e(%rip)      # 0x10a80
movq -0x10(%rbp), %rdx
movq 0x7f3b(%rip), %rax      # 0x10a78
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
leaq 0x7f20(%rip), %rcx      # 0x10a70
movslq (%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8ae6
leaq 0x7e9(%rip), %rax       # 0x9360
movq %rax, 0x77da(%rip)      # 0x10358
callq 0x9360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7ecd(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7d83(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8bdf
movq -0x10(%rbp), %rax
leaq 0x7ea2(%rip), %rcx      # 0x10a70
movslq (%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x8be1
jmp 0x8be7
callq *0x7771(%rip)           # 0x10358
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x35dd(%rip), %rdi      # 0xc1ec
movb $0x0, %al
callq 0x3060
movl -0xc(%rbp), %eax
leaq 0x7e50(%rip), %rcx      # 0x10a70
cmpl (%rcx), %eax
jne 0x8c29
jmp 0x8cf8
leaq 0x7e40(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7cf6(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x8c69
leaq 0x7e21(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7cd7(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x5d40
leaq 0x7e00(%rip), %rax      # 0x10a70
movl (%rax), %edi
movl $0x1, %esi
leaq -0x2afe(%rip), %rdx     # 0x6180
callq 0x7ea0
leaq 0x77ce(%rip), %rax      # 0x10458
movq (%rax), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x3530
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
leaq -0x2b99(%rip), %rdx     # 0x6110
callq 0x7ea0
movl -0xc(%rbp), %ecx
leaq 0x7db8(%rip), %rax      # 0x10a70
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x7c6b(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x8cf0
movslq -0xc(%rbp), %rcx
leaq 0x7c52(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x5f60
jmp 0x8cf8
movl -0xc(%rbp), %edi
callq 0x8810
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x7d54(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7c0a(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x8d67
movl -0xc(%rbp), %eax
leaq 0x7d32(%rip), %rcx      # 0x10a70
cmpl (%rcx), %eax
je 0x8d67
leaq 0x7d27(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7bdd(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0xc8(%rax)
je 0x8d6c
jmp 0x8e42
leaq 0x7cfd(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7bb3(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl $0x1, 0x194(%rax)
leaq 0x76af(%rip), %rax      # 0x10448
movq (%rax), %rdi
leaq 0x7ccd(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7b83(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movl 0xd0(%rax), %esi
callq 0x3560
movl %eax, -0x10(%rbp)
leaq 0x7ca3(%rip), %rax      # 0x10a70
movl (%rax), %edi
leaq 0x7c9a(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7b50(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rsi
callq 0x8340
movl -0xc(%rbp), %edi
leaq 0x7c76(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7b2c(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rsi
callq 0x7f90
leaq 0x7c55(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7b0b(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x48(%rax)
leaq 0x7c35(%rip), %rax      # 0x10a70
movl (%rax), %edi
callq 0x8810
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7b0d(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x79c3(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
jne 0x8f80
jmp 0x9083
leaq 0x7ae9(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x799f(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x18c(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x7abc(%rip), %rax      # 0x10a70
movslq (%rax), %rdx
leaq 0x7972(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movq 0x48(%rax), %rax
movl %ecx, 0x18c(%rax)
leaq 0x7a9a(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7950(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x190(%rax)
je 0x8ff9
jmp 0x9083
leaq 0x7a70(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7926(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x18c(%rax)
jne 0x9041
leaq 0x7a4b(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7901(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x63a0
jmp 0x9083
leaq 0x7a28(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x78de(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x6370
leaq 0x7a07(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x78bd(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x6710
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x7865(%rip), %rax      # 0x10a70
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %edx
movl %edx, %esi
callq 0x8720
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9266
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x9266
movq -0x18(%rbp), %rax
leaq 0x782e(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x76e4(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
jne 0x9266
movq -0x18(%rbp), %rax
cmpl $0x0, 0x164(%rax)
je 0x9268
jmp 0x92a3
movq -0x18(%rbp), %rax
movl 0x114(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x160(%rax)
movl $0x20, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x8, %esi
leaq -0x1c(%rbp), %rdx
callq 0x63f0
movq -0x18(%rbp), %rax
movl $0x1, 0x164(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x77a5(%rip), %rax      # 0x10a70
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %edx
movl %edx, %esi
callq 0x8720
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9326
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x9326
movq -0x18(%rbp), %rax
leaq 0x776e(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x7624(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
jne 0x9326
movq -0x18(%rbp), %rax
cmpl $0x0, 0x164(%rax)
jne 0x9328
jmp 0x934f
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x160, %rdx            # imm = 0x160
movl $0x8, %esi
callq 0x63f0
movq -0x18(%rbp), %rax
movl $0x0, 0x164(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x7712(%rip), %eax      # 0x10a80
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x9396
movq 0x76fa(%rip), %rax      # 0x10a78
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5c80
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9371
movl 0x76e4(%rip), %eax      # 0x10a80
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x76c4(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x757a(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x28(%rcx), %eax
jae 0x93cd
movl -0x8(%rbp), %eax
movl %eax, 0x76b5(%rip)      # 0x10a80
jmp 0x93d7
movl $0x0, 0x76a9(%rip)      # 0x10a80
movq 0x769a(%rip), %rax      # 0x10a78
movl 0x769c(%rip), %ecx      # 0x10a80
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c80
movq -0x10(%rbp), %rdi
callq 0x5ac0
movq -0x10(%rbp), %rdi
callq 0x5f60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0xadf0
leaq 0x701e(%rip), %rax      # 0x10448
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3050
movl %eax, -0xc(%rbp)
leaq 0x7006(%rip), %rax      # 0x10444
movl $0x0, (%rax)
leaq 0x7085(%rip), %rax      # 0x104d0
movq $0x0, 0x30(%rax)
leaq 0x7076(%rip), %rax      # 0x104d0
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: grab_pointer_cursor
static void grab_pointer_cursor(xcb_cursor_t cursor) {
	uint32_t mask = XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_BUTTON_MOTION |
			XCB_EVENT_MASK_POINTER_MOTION;
	uint32_t type = XCB_GRAB_MODE_ASYNC;
	xcb_grab_pointer(conn, 1, scr->root, mask, type, type, scr->root, cursor,
			XCB_CURRENT_TIME);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x2048, -0x8(%rbp)     # imm = 0x2048
movl $0x1, -0xc(%rbp)
leaq 0x6fa8(%rip), %rax      # 0x10448
movq (%rax), %rdi
leaq 0x6fa6(%rip), %rax      # 0x10450
movq (%rax), %rax
movl (%rax), %edx
movl -0x8(%rbp), %eax
movw %ax, %cx
movl -0xc(%rbp), %eax
movb %al, %r8b
movl -0xc(%rbp), %eax
movb %al, %r9b
leaq 0x6f88(%rip), %rax      # 0x10450
movq (%rax), %rax
movl (%rax), %r10d
movl -0x4(%rbp), %eax
movl $0x1, %esi
xorl %r11d, %r11d
movzwl %cx, %ecx
movzbl %r8b, %r8d
movzbl %r9b, %r9d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x3150
movl %eax, -0x10(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x735a(%rip), %rax      # 0x10a70
movl (%rax), %edi
movl -0x8(%rbp), %ecx
movl $0x1, %edx
movl %edx, %esi
callq 0x8720
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9761
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x9761
movq -0x18(%rbp), %rax
leaq 0x7326(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x71dc(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
je 0x976a
movl $0x0, -0x4(%rbp)
jmp 0x97e5
leaq 0x72ff(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x71b5(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x5d00
leaq 0x72de(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7194(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x190(%rax)
jne 0x97d5
leaq 0x72b9(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x716f(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x18c(%rax)
je 0x97de
movl $0x0, -0x4(%rbp)
jmp 0x97e5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x726d(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x7123(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x7, 0x178(%rax)
je 0x9842
leaq 0x7248(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x70fe(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0xa710
xorl %eax, %eax
movl %eax, %edi
callq 0xa070
leaq 0x6c7e(%rip), %rax      # 0x104d0
leaq 0x817(%rip), %rcx       # 0xa070
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x988c
jmp 0x98bf
leaq 0x707d(%rip), %rax      # 0x10910
movl 0x10(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9950
movq -0x8(%rbp), %rdi
callq 0x9990
leaq 0x6c1c(%rip), %rax      # 0x104d0
leaq 0x115(%rip), %rcx       # 0x99d0
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)