LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/window.c
// Function: cursor_init
void cursor_init(void) {
	xcb_font_t cursor_font = xcb_generate_id(conn);
	xcb_open_font(conn, cursor_font, strlen("cursor"), "cursor");

	XRenderColor cursor_fg = hex_to_rgb(CURSOR_FG);
	XRenderColor cursor_bg = hex_to_rgb(CURSOR_BG);

	default_cursor = cursor_create(cursor_font, cursor_fg, cursor_bg, CURSOR_DEFAULT);
	
	for (int i = 0; i < 8; i++) {
		resize_cursors[i] = cursor_create(cursor_font, cursor_fg, cursor_bg, resize_cursor_indicies[i]);
	}

	xcb_close_font_checked(conn, cursor_font);

	xcb_change_window_attributes(conn, scr->root, XCB_CW_CURSOR, &default_cursor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7d82(%rip), %r14      # 0xd448
movq (%r14), %rdi
callq 0x3550
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x3af6(%rip), %rcx      # 0x91d0
pushq $0x6
popq %rdx
movl %eax, %esi
callq 0x3090
movl $0xffd7d7d7, %edi       # imm = 0xFFD7D7D7
callq 0x7fe8
movq %rax, %r14
movl $0xff242223, %edi       # imm = 0xFF242223
callq 0x7fe8
movq %rax, %r15
pushq $0x44
popq %rcx
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x578a
movl %eax, 0x81ec(%rip)      # 0xd900
leaq 0x81f5(%rip), %r13      # 0xd910
xorl %r12d, %r12d
cmpq $0x10, %r12
je 0x574b
leaq 0x3a55(%rip), %rax      # 0x9180
movzwl (%r12,%rax), %ecx
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x578a
movl %eax, (%r13)
addq $0x2, %r12
addq $0x4, %r13
jmp 0x571e
leaq 0x7cf6(%rip), %r14      # 0xd448
movq (%r14), %rdi
movl %ebx, %esi
callq 0x33f0
movq (%r14), %rdi
leaq 0x7cea(%rip), %rax      # 0xd450
movq (%rax), %rax
movl (%rax), %esi
leaq 0x818e(%rip), %rcx      # 0xd900
movl $0x4000, %edx           # imm = 0x4000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33a0
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/window.c
// Function: cursor_create
static xcb_cursor_t cursor_create(xcb_font_t font, XRenderColor fg, XRenderColor bg, uint16_t index) {
	xcb_cursor_t cursor = xcb_generate_id(conn);
	xcb_create_glyph_cursor(conn, cursor, font, font, index, index + 1, fg.red, fg.green, fg.blue,
			bg.red, bg.green, bg.blue);
	return cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movl %edi, -0x30(%rbp)
movl %r15d, %eax
shrl $0x10, %eax
movq %rax, -0x40(%rbp)
movq %rsi, %rbx
shrq $0x20, %rbx
movl %r13d, %r12d
shrl $0x10, %r12d
movq %rdx, %r14
shrq $0x20, %r14
leaq 0x7c7a(%rip), %rax      # 0xd448
movq (%rax), %rdi
callq 0x3550
movl %eax, %esi
movl %eax, -0x2c(%rbp)
leaq 0x7c66(%rip), %rax      # 0xd448
movq (%rax), %rdi
movq -0x38(%rbp), %r8
leal 0x1(%r8), %r9d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r14d
andl %eax, %r13d
andl %eax, %ebx
andl %eax, %r15d
andl %eax, %r9d
movl -0x30(%rbp), %ecx
movl %ecx, %edx
pushq %r14
pushq %r12
pushq %r13
pushq %rbx
pushq -0x40(%rbp)
pushq %r15
callq 0x35b0
addq $0x30, %rsp
movl -0x2c(%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/window.c
// Function: install_normal_hints
void install_normal_hints(window *win) {
	if (!xcb_icccm_get_wm_normal_hints_reply(conn, xcb_icccm_get_wm_normal_hints_unchecked(conn,
			win->windows[WIN_CHILD]), &win->hints, NULL)) {
		memset(&win->hints, 0, sizeof(xcb_size_hints_t));
		return;	
	}

#define MIN_WIDTH 160
#define MIN_HEIGHT 90

	if ((win->hints.flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE) &&
			!(win->hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)) {
		win->hints.min_width = win->hints.base_width;
		win->hints.min_height = win->hints.base_height;
	} else {
		win->hints.min_width = MIN_WIDTH;
		win->hints.min_height = MIN_HEIGHT;
	}

	if (!(win->hints.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC)) {
		win->hints.width_inc = 1;
		win->hints.height_inc = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7bbc(%rip), %rax      # 0xd448
movq (%rax), %r15
movl 0xcc(%rdi), %esi
movq %r15, %rdi
callq 0x30b0
leaq 0x118(%rbx), %r14
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3620
testb %al, %al
je 0x58d8
movl (%r14), %eax
movl %eax, %ecx
andl $0x110, %ecx            # imm = 0x110
cmpl $0x100, %ecx            # imm = 0x100
jne 0x58f5
movl 0x154(%rbx), %edx
movl 0x158(%rbx), %ecx
jmp 0x58fd
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
andq $0x0, 0x40(%r14)
jmp 0x591e
pushq $0x5a
popq %rcx
movl $0xa0, %edx
movl %edx, 0x12c(%rbx)
movl %ecx, 0x130(%rbx)
testb $0x40, %al
jne 0x591e
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x13c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/window.c
// Function: create_window_new
void create_window_new(xcb_window_t child) {
	window *win = allocate_window(child);

	uint32_t w;
	uint32_t h;
	uint32_t x;
	uint32_t y;
	xcb_get_geometry_reply_t *geom = w_get_geometry(child);
	if (win->hints.flags & XCB_ICCCM_SIZE_HINT_US_POSITION) {
		w = geom->width;
		h = geom->height;
		x = geom->x;
		y = geom->y;
	} else {
		xcb_query_pointer_reply_t *ptr = w_query_pointer();
		w = size_helper(geom->width + 2 * PAD, scr->width_in_pixels);
		h = size_helper(geom->height + PAD_N + PAD, scr->height_in_pixels - TOP - BOT);
		x = place_helper(ptr->root_x, w, scr->width_in_pixels);
		y = TOP + place_helper(ptr->root_y - TOP, h, scr->height_in_pixels - TOP - BOT);
		free(ptr);
	}
	free(geom);

	create_window(win, x, y, w, h);
	
	insert_into(curws, win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
callq 0x5a39
movq %rax, %rbx
movl %r14d, %edi
callq 0x5ae8
movq %rax, %r14
movq %rbx, -0x30(%rbp)
testb $0x1, 0x118(%rbx)
jne 0x59bb
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x372c
movzwl 0x10(%r14), %r15d
addl $0x2, %r15d
leaq 0x7adc(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movzwl 0x14(%rcx), %edx
cmpl %edx, %r15d
cmovael %edx, %r15d
movzwl 0x12(%r14), %r13d
addl $0x21, %r13d
movzwl 0x16(%rcx), %ecx
cmpl %ecx, %r13d
cmovael %ecx, %r13d
movswl 0x10(%rax), %edi
movl %r15d, %r8d
shrl %r8d
movl %edi, %esi
movl $0x0, %ebx
subl %r8d, %esi
jb 0x59d3
addl %edi, %r8d
cmpl %edx, %r8d
jbe 0x59d1
subl %r15d, %edx
movl %edx, %ebx
jmp 0x59d3
movzwl 0x10(%r14), %r15d
movzwl 0x12(%r14), %r13d
movswl 0xc(%r14), %ebx
movswl 0xe(%r14), %r12d
jmp 0x59fb
movl %esi, %ebx
movswl 0x12(%rax), %esi
movl %r13d, %edi
shrl %edi
movl %esi, %edx
subl %edi, %edx
jb 0x59f3
addl %esi, %edi
cmpl %ecx, %edi
jbe 0x59f0
subl %r13d, %ecx
movl %ecx, %r12d
jmp 0x59f3
movl %edx, %r12d
movq %rax, %rdi
callq 0x3270
movq %r14, %rdi
callq 0x3270
movq -0x30(%rbp), %r14
movq %r14, %rdi
movl %ebx, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
callq 0x5b11
leaq 0x804f(%rip), %rax      # 0xda70
movl (%rax), %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6378
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/window.c
// Function: allocate_window
static window *allocate_window(xcb_window_t child) {
	window *win = malloc(sizeof(window));
	win->windows[WIN_PARENT] = XCB_WINDOW_NONE;
	win->windows[WIN_CHILD] = child;
	win->ignore_unmap = 0;
	win->is_roll = 0;
	win->snap_index = SNAP_NONE;
	win->is_e_full = 0;
	win->is_i_full = 0;
	win->sticky = 0;
	win->above = 0;
	win->normal = 1;

	window_property_helper(xcb_ewmh_get_wm_window_type(ewmh, child), win, test_window_type);
	window_property_helper(xcb_ewmh_get_wm_state(ewmh, child), win, test_window_state);

	install_normal_hints(win);

	return win;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movl $0x198, %edi            # imm = 0x198
callq 0x3160
movq %rax, %rbx
andl $0x0, 0xd0(%rax)
movl %r14d, 0xcc(%rax)
andl $0x0, 0x194(%rax)
andl $0x0, 0x164(%rax)
movl $0x7, 0x178(%rax)
andq $0x0, 0x18c(%rax)
andl $0x0, 0xc8(%rax)
movq $0x1, 0xc0(%rax)
leaq 0x79be(%rip), %r15      # 0xd458
movq (%r15), %rdi
movl %r14d, %esi
callq 0x3080
leaq 0x6ac(%rip), %rdx       # 0x6158
movl %eax, %edi
movq %rbx, %rsi
callq 0x60ef
movq (%r15), %rdi
movl %r14d, %esi
callq 0x3210
leaq 0x70c(%rip), %rdx       # 0x61d4
movl %eax, %edi
movq %rbx, %rsi
callq 0x60ef
movq %rbx, %rdi
callq 0x5878
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
callq 0x5a39
movq %rax, %rbx
movl %r14d, %edi
callq 0x5ae8
movzwl 0x10(%rax), %r14d
addl $0x2, %r14d
leaq 0x740e(%rip), %rcx      # 0xd450
movq (%rcx), %rcx
movzwl 0x14(%rcx), %edx
cmpl %edx, %r14d
cmovael %edx, %r14d
movzwl 0x12(%rax), %r15d
addl $0x21, %r15d
movzwl 0x16(%rcx), %ecx
cmpl %ecx, %r15d
cmovael %ecx, %r15d
movswl 0xc(%rax), %esi
leal -0x1(%rsi), %edi
leal (%rsi,%r14), %r8d
decl %r8d
movl %edx, %r12d
subl %r14d, %r12d
cmpl %edx, %r8d
cmovbel %edi, %r12d
xorl %edx, %edx
testl %esi, %esi
cmovlel %edx, %r12d
movswl 0xe(%rax), %esi
leal -0x20(%rsi), %edi
leal (%rsi,%r15), %r8d
addl $-0x20, %r8d
movl %ecx, %r13d
subl %r15d, %r13d
cmpl %ecx, %r8d
cmovbel %edi, %r13d
cmpl $0x20, %esi
cmovll %edx, %r13d
movq %rax, %rdi
callq 0x3270
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x5b11
movl $0x1, 0x194(%rbx)
leaq 0x7999(%rip), %rax      # 0xda70
movl (%rax), %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6378
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %esi
leaq 0x734d(%rip), %rax      # 0xd458
movq (%rax), %rdi
xorl %r15d, %r15d
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3110
testb %al, %al
jne 0x613e
jmp 0x614d
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x30(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq *%rbx
incl %r15d
cmpl -0x30(%rbp), %r15d
jb 0x6122
leaq -0x30(%rbp), %rdi
callq 0x3610
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rbp), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
leaq 0x72e1(%rip), %rcx      # 0xd458
movq (%rcx), %rcx
cmpl 0xd4(%rcx), %eax
je 0x6192
cmpl 0xd8(%rcx), %eax
je 0x6192
cmpl 0xd0(%rcx), %eax
jne 0x61cb
andl $0x0, 0xc0(%rbx)
leaq -0x14(%rbp), %rcx
movl $0x20000, (%rcx)        # imm = 0x20000
leaq 0x729e(%rip), %r14      # 0xd448
movq (%r14), %rdi
movl 0xcc(%rbx), %esi
movl $0x800, %edx            # imm = 0x800
callq 0x33a0
movq (%r14), %rdi
movl 0xcc(%rbx), %esi
callq 0x3230
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbp), %r14
movslq %esi, %r15
movl (%r14,%r15,4), %eax
leaq 0x7264(%rip), %r12      # 0xd458
movq (%r12), %rcx
cmpl 0x10c(%rcx), %eax
jne 0x6210
movq %rbx, %rdi
callq 0x5198
movl (%r14,%r15,4), %eax
movq (%r12), %rcx
cmpl 0x12c(%rcx), %eax
jne 0x6222
movl $0x1, 0xc4(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movslq %edi, %rbx
imulq $0x50, %rbx, %rax
leaq 0x76e8(%rip), %rcx      # 0xd930
leaq (%rcx,%rax), %r15
movq 0x48(%rax,%rcx), %rax
testq %rax, %rax
je 0x625e
movl 0xcc(%rax), %edx
jmp 0x6260
xorl %edx, %edx
leaq 0x2f70(%rip), %rdi      # 0x91d7
movl %ebx, %esi
xorl %eax, %eax
callq 0x3060
movslq %r14d, %r12
imulq $0x18, %r12, %rax
addq %rax, %r15
leaq 0x2f70(%rip), %r14      # 0x91f1
imulq $0x18, %rbx, %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x62a7
movl 0xcc(%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3060
addq %rbx, %r15
leaq (%r15,%r12,8), %r15
jmp 0x6285
leaq 0x2f78(%rip), %rdi      # 0x9226
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x50, %rax, %rcx
leaq 0x75e7(%rip), %rdx      # 0xd930
addq %rcx, %rdx
movslq %esi, %r14
imulq $0x18, %r14, %rcx
movq (%rcx,%rdx), %rdi
imulq $0x18, %rax, %r15
testq %rdi, %rdi
je 0x636f
leaq (%rdi,%r15), %rax
movq (%rax,%r14,8), %r12
callq *%rbx
movq %r12, %rdi
jmp 0x635b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
xorl %esi, %esi
movq %r14, %rdx
callq 0x6413
cmpl $0x0, 0xc0(%r14)
je 0x63af
movq %r14, %rdi
callq 0x4d51
pushq $0x1
popq %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x6413
jmp 0x63b7
movq %r14, %rdi
callq 0x4d41
cmpl $0x0, 0xc4(%r14)
je 0x63cf
pushq $0x2
popq %rsi
movl %ebx, %edi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x6413
cmpl $0x0, 0x18c(%r14)
jne 0x63e3
cmpl $0x0, 0x190(%r14)
je 0x63e8
popq %rbx
popq %r14
popq %rbp
retq
movslq %ebx, %rax
imulq $0x50, %rax, %rcx
leaq 0x753a(%rip), %rdx      # 0xd930
movq 0x30(%rcx,%rdx), %rdi
imulq $0x18, %rax, %rbx
testq %rdi, %rdi
je 0x63e3
movq 0x10(%rdi,%rbx), %r14
callq 0x4d61
movq %r14, %rdi
jmp 0x63ff
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rax
imulq $0x50, %rax, %rcx
leaq 0x750b(%rip), %rdi      # 0xd930
addq %rcx, %rdi
movl %esi, %ecx
imulq $0x18, %rcx, %rsi
addq %rdi, %rsi
addq $0x8, %rsi
movq -0x8(%rsi), %rdi
imulq $0x18, %rax, %rax
leaq (%rdx,%rax), %r8
movq %rdi, (%r8,%rcx,8)
andq $0x0, 0x60(%r8,%rcx,8)
movq -0x8(%rsi), %rdi
addq %rdi, %rax
testq %rdi, %rdi
leaq 0x60(%rax,%rcx,8), %rax
cmoveq %rsi, %rax
movq %rdx, (%rax)
movq %rdx, -0x8(%rsi)
incl 0x8(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
xorl %esi, %esi
movq %rbx, %rdx
callq 0x64d8
cmpl $0x0, 0xc0(%rbx)
je 0x64a2
movq %rbx, %rdi
callq 0x4d31
pushq $0x1
popq %rsi
movl %r14d, %edi
movq %rbx, %rdx
callq 0x64d8
jmp 0x64aa
movq %rbx, %rdi
callq 0x4d21
cmpl $0x0, 0xc4(%rbx)
jne 0x64b8
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6b31(%rip), %rax      # 0xcff0
movq (%rax), %rcx
leaq 0x2d33(%rip), %rdi      # 0x91fc
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x35a0
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rax
imulq $0x50, %rax, %rcx
leaq 0x7446(%rip), %rdi      # 0xd930
addq %rcx, %rdi
movl %esi, %ecx
imulq $0x18, %rcx, %rsi
movq 0x8(%rsi,%rdi), %r8
imulq $0x18, %rax, %rax
leaq (%rdx,%rax), %r9
movq %r8, 0x60(%r9,%rcx,8)
andq $0x0, (%r9,%rcx,8)
leaq (%rdi,%rsi), %r8
movq 0x8(%rsi,%rdi), %r9
addq %r9, %rax
testq %r9, %r9
leaq (%rax,%rcx,8), %rax
cmoveq %r8, %rax
movq %rdx, (%rax)
movq %rdx, 0x8(%rsi,%rdi)
incl 0x10(%rsi,%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/workspace.c
// Function: excise_from
void excise_from(int ws, window *win) {
	if (win->normal) {
		excise_from_helper(ws, TYPE_NORMAL, win);
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rax
movl %esi, %ecx
imulq $0x18, %rax, %rsi
addq %rsi, %rdx
movq (%rdx,%rcx,8), %rdi
movq 0x60(%rdx,%rcx,8), %r8
imulq $0x50, %rax, %rax
leaq 0x7394(%rip), %r9       # 0xd930
addq %rax, %r9
imulq $0x18, %rcx, %rax
leaq (%rdi,%rsi), %r10
testq %rdi, %rdi
leaq 0x8(%rax,%r9), %rdi
leaq 0x60(%r10,%rcx,8), %r10
cmoveq %rdi, %r10
addq %r9, %rax
movq %r8, (%r10)
addq %r8, %rsi
testq %r8, %r8
movq (%rdx,%rcx,8), %rdx
leaq (%rsi,%rcx,8), %rcx
cmoveq %rax, %rcx
movq %rdx, (%rcx)
decl 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r12d, %r12d
testl %edi, %edi
cmovlel %r12d, %r15d
cmpl %r12d, %r15d
je 0x6620
movl %r12d, %edi
movq %r14, %rsi
callq *%rbx
incl %r12d
jmp 0x6603
incl %r15d
movl %r15d, %edi
movq %r14, %rsi
callq *%rbx
cmpl $0x2, %r15d
jbe 0x6615
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/workspace.c
// Function: search_helper
search_data search_helper(int ws, int type, xcb_window_t id, int (*func)(window *, xcb_window_t)) {
	search_data ret;
	for (ret.win = stack[ws].lists[type].first; ret.win; ret.win = ret.win->next[ws][type]) {
		ret.index = func(ret.win, id);
		if (-1 < ret.index) {
			return ret;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movslq %edi, %rcx
imulq $0x50, %rcx, %rax
leaq 0x72d1(%rip), %rdx      # 0xd930
addq %rax, %rdx
movslq %esi, %r12
imulq $0x18, %r12, %rax
addq %rdx, %rax
imulq $0x18, %rcx, %r13
movq (%rax), %r15
testq %r15, %r15
je 0x668f
movq %r15, %rdi
movl %r14d, %esi
callq *%rbx
movl %eax, %edx
testl %eax, %eax
jns 0x668f
addq %r13, %r15
leaq (%r15,%r12,8), %rax
jmp 0x6670
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %r9
imulq $0x50, %r9, %rax
leaq 0x727d(%rip), %rdi      # 0xd930
addq %rax, %rdi
movslq %esi, %rsi
imulq $0x18, %rsi, %rax
addq %rdi, %rax
movslq %edx, %rdi
movslq %ecx, %rcx
imulq $0x18, %r9, %r9
movq (%rax), %rax
testq %rax, %rax
je 0x66f2
movq %rdi, %rdx
cmpq %rcx, %rdx
jge 0x66e9
cmpl %r8d, 0xcc(%rax,%rdx,4)
je 0x66f2
incq %rdx
jmp 0x66d5
addq %r9, %rax
leaq (%rax,%rsi,8), %rax
jmp 0x66ca
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rdi
imulq $0x50, %rdi, %rax
leaq 0x722a(%rip), %r8       # 0xd930
addq %rax, %r8
movslq %esi, %rsi
imulq $0x18, %rsi, %rax
addq %r8, %rax
movslq %edx, %rdx
imulq $0x18, %rdi, %rdi
movq (%rax), %rax
testq %rax, %rax
je 0x6734
cmpl %ecx, 0xcc(%rax,%rdx,4)
je 0x6734
addq %rdi, %rax
leaq (%rax,%rsi,8), %rax
jmp 0x671a
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x4, %r14d
je 0x6774
movl %r14d, %edi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x66f4
testq %rax, %rax
jne 0x6778
incl %r14d
jmp 0x6753
xorl %eax, %eax
jmp 0x6780
testq %rbx, %rbx
je 0x6780
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x50, %rax, %rax
leaq 0x718f(%rip), %rcx      # 0xd930
movq 0x18(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x67b1
popq %rbp
jmp 0x4f64
leaq 0x6c90(%rip), %rax      # 0xd448
movq (%rax), %rdi
leaq 0x6c8e(%rip), %rax      # 0xd450
movq (%rax), %rax
movl (%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
popq %rbp
jmp 0x3140
// File: /workspace/github_c_makefile_star2_O2/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 0x7260(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
imulq $0x50, %rax, %rax
leaq 0x7112(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rax
testq %rax, %rax
je 0x6889
leaq 0x6c19(%rip), %r15      # 0xd448
movq (%r15), %rdi
movl 0xd0(%rax), %esi
callq 0x3560
movq (%r15), %rdi
movslq (%rbx), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r14,%rax), %rax
movl 0xcc(%rax), %esi
callq 0x3560
movslq (%rbx), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r14,%rax), %rax
movl 0xcc(%rax), %edi
callq 0x3756
movslq (%rbx), %rsi
imulq $0x50, %rsi, %rax
movq 0x48(%r14,%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x54d6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6ba5(%rip), %rax      # 0xd444
andl $0x0, (%rax)
leaq -0x309b(%rip), %rax     # 0x380e
leaq 0x6c20(%rip), %rcx      # 0xd4d0
movq %rax, 0x38(%rcx)
leaq -0x3009(%rip), %rax     # 0x38b2
movq %rax, 0x40(%rcx)
leaq 0x71aa(%rip), %rax      # 0xda70
movl (%rax), %edi
leaq -0x1cba(%rip), %rdx     # 0x4c15
pushq $0x1
popq %rsi
callq 0x62e1
leaq 0x14(%rip), %rax        # 0x68f2
movq %rax, 0x6a6b(%rip)      # 0xd350
movq 0x718c(%rip), %rdi      # 0xda78
popq %rbp
jmp 0x3270
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
leaq 0x6b41(%rip), %rax      # 0xd444
movl $0x3, (%rax)
xorps %xmm0, %xmm0
leaq 0x6bbd(%rip), %rax      # 0xd4d0
movups %xmm0, 0x38(%rax)
leaq 0x7152(%rip), %rbx      # 0xda70
movl (%rbx), %edi
leaq -0x1d47(%rip), %rdx     # 0x4be0
pushq $0x1
popq %rsi
callq 0x62e1
movslq (%rbx), %r15
imulq $0x50, %r15, %rax
leaq 0x6ff3(%rip), %rcx      # 0xd930
leaq (%rcx,%rax), %rbx
addq $0x18, %rbx
movslq 0x10(%rbx), %r14
leaq (,%r14,8), %rdi
callq 0x3160
movq %rax, 0x711b(%rip)      # 0xda78
xorl %ecx, %ecx
imulq $0x18, %r15, %rdx
movq %rbx, %rsi
cmpq %r14, %rcx
jge 0x698f
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x698f
cmpq 0x30(%rbx), %rsi
jne 0x697f
movl %ecx, 0x7101(%rip)      # 0xda80
movq %rsi, (%rax,%rcx,8)
addq %rdx, %rsi
addq $0x8, %rsi
incq %rcx
jmp 0x6966
leaq 0x46a(%rip), %rax       # 0x6e00
movq %rax, 0x69b3(%rip)      # 0xd350
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6e00
// File: /workspace/github_c_makefile_star2_O2/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 0x70b9(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rcx
leaq 0x6f6b(%rip), %rdx      # 0xd930
movq 0x18(%rdx,%rcx), %rcx
testq %rcx, %rcx
je 0x69e2
imulq $0x18, %rax, %rax
cmpq $0x0, 0x8(%rcx,%rax)
je 0x69e2
popq %rbp
jmpq *0x696e(%rip)           # 0xd350
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ebx
leaq 0x2830(%rip), %rdi      # 0x922b
movl %ebx, %esi
xorl %eax, %eax
callq 0x3060
leaq 0x7065(%rip), %r15      # 0xda70
movl (%r15), %edi
cmpl %edi, %ebx
jne 0x6a21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebx, %r12
movslq %edi, %rax
imulq $0x50, %rax, %rax
leaq 0x6efe(%rip), %r13      # 0xd930
movq 0x48(%r13,%rax), %rax
testq %rax, %rax
je 0x6a47
movq %rax, %rdi
callq 0x4dde
movl (%r15), %edi
leaq -0x1989(%rip), %rdx     # 0x50c5
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x62e1
leaq 0x69f7(%rip), %rax      # 0xd458
movq (%rax), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x3530
leaq -0x19f2(%rip), %rdx     # 0x5082
movl %ebx, %edi
movl %r14d, %esi
callq 0x62e1
movl %ebx, (%r15)
imulq $0x50, %r12, %rax
movq 0x48(%r13,%rax), %rdi
testq %rdi, %rdi
je 0x6aa2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f64
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x678f
// File: /workspace/github_c_makefile_star2_O2/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 0x6fa6(%rip), %r14      # 0xda70
movl (%r14), %eax
movslq %eax, %rcx
imulq $0x50, %rcx, %rax
leaq 0x6e55(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
testq %rax, %rax
sete %dl
cmpl %ecx, %ebx
sete %cl
orb %dl, %cl
jne 0x6af8
cmpl $0x0, 0xc8(%rax)
je 0x6b03
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, 0x194(%rax)
leaq 0x6934(%rip), %rcx      # 0xd448
movq (%rcx), %rdi
movl 0xd0(%rax), %esi
callq 0x3560
movslq (%r14), %rdi
imulq $0x50, %rdi, %rax
movq 0x48(%r15,%rax), %rsi
callq 0x652f
movslq (%r14), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r15,%rax), %rsi
movl %ebx, %edi
callq 0x6378
movslq (%r14), %rdi
imulq $0x50, %rdi, %rax
andq $0x0, 0x48(%r15,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x678f
// File: /workspace/github_c_makefile_star2_O2/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 0x6e88(%rip), %rbx      # 0xda70
movslq (%rbx), %rax
imulq $0x50, %rax, %rax
leaq 0x6d3a(%rip), %r14      # 0xd930
movq 0x48(%r14,%rax), %rdi
testq %rdi, %rdi
je 0x6c1c
movl 0x18c(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0x18c(%rdi)
cmpl $0x0, 0x190(%rdi)
je 0x6c21
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
je 0x6c2e
popq %rbx
popq %r14
popq %rbp
jmp 0x5217
callq 0x51f4
movslq (%rbx), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r14,%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5433
// File: /workspace/github_c_makefile_star2_O2/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 0x6d53(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
pushq $0x1
popq %rdx
movl %eax, %edi
movl %edx, %esi
callq 0x66f4
testq %rax, %rax
je 0x6d88
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x6d88
movslq (%r14), %rax
imulq $0x50, %rax, %rax
leaq 0x6be3(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x6d88
cmpl $0x0, 0x164(%rbx)
jne 0x6d88
movl 0x114(%rbx), %eax
movl %eax, 0x160(%rbx)
leaq -0x14(%rbp), %rdx
movl $0x20, (%rdx)
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x5243
movl $0x1, 0x164(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6cd1(%rip), %r14      # 0xda70
movl (%r14), %eax
movl (%rdi), %ecx
pushq $0x1
popq %rdx
movl %eax, %edi
movl %edx, %esi
callq 0x66f4
testq %rax, %rax
je 0x6dfb
movq %rax, %rbx
cmpl $0x0, 0xc0(%rax)
je 0x6dfb
movslq (%r14), %rax
imulq $0x50, %rax, %rax
leaq 0x6b61(%rip), %rcx      # 0xd930
cmpq 0x48(%rcx,%rax), %rbx
jne 0x6dfb
cmpl $0x0, 0x164(%rbx)
je 0x6dfb
movq %rbx, %rdx
addq $0x160, %rdx            # imm = 0x160
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x5243
andl $0x0, 0x164(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x6c74(%rip), %ebx      # 0xda80
testl %ebx, %ebx
js 0x6e26
movq 0x6c61(%rip), %rax      # 0xda78
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x4d61
decl %ebx
jmp 0x6e0c
movl 0x6c54(%rip), %eax      # 0xda80
incl %eax
leaq 0x6c3b(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x6aed(%rip), %rdx      # 0xd930
xorl %esi, %esi
cmpl 0x28(%rdx,%rcx), %eax
cmovbl %eax, %esi
movl %esi, 0x6c2e(%rip)      # 0xda80
movq 0x6c1f(%rip), %rax      # 0xda78
movq (%rax,%rsi,8), %rbx
movq %rbx, %rdi
callq 0x4d61
movq %rbx, %rdi
callq 0x4c7f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f64
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7ef0
leaq 0x65ba(%rip), %rax      # 0xd448
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3050
leaq 0x65a5(%rip), %rax      # 0xd444
andl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x6624(%rip), %rax      # 0xd4d0
movups %xmm0, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6fc6
testl %eax, %eax
je 0x6f60
leaq 0x12e(%rip), %rax       # 0x7041
leaq 0x65b6(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
leaq -0xa9(%rip), %rax       # 0x6e7c
movq %rax, 0x28(%rcx)
leaq 0x6b40(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x69f2(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
cmpl $0x7, 0x178(%rdi)
jne 0x6f67
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
subl 0x108(%rdi), %ecx
subl 0x10c(%rdi), %eax
jmp 0x6f9b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
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, 0x6ae3(%rip)      # 0xda84
movl %eax, 0x6ae1(%rip)      # 0xda88
leaq 0x6496(%rip), %rax      # 0xd444
movl $0x1, (%rax)
xorl %eax, %eax
callq 0x7eaa
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6eb2
// File: /workspace/github_c_makefile_star2_O2/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 0x6a97(%rip), %r14      # 0xda70
movl (%r14), %edi
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x66f4
xorl %ebx, %ebx
testq %rax, %rax
je 0x7034
cmpl $0x0, 0xc0(%rax)
je 0x7034
movslq (%r14), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x692c(%rip), %r15      # 0xd930
movq 0x48(%r15,%rcx), %rdi
cmpq %rdi, %rax
jne 0x7034
callq 0x4db7
movslq (%r14), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r15,%rax), %rax
cmpl $0x0, 0x190(%rax)
jne 0x7034
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_O2/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 0x6a24(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x68d6(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
cmpl $0x7, 0x178(%rdi)
je 0x706d
callq 0x7b27
callq 0x76a1
leaq 0x628(%rip), %rax       # 0x76a1
leaq 0x6450(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x70f1
leaq 0x6871(%rip), %rax      # 0xd910
movl 0x10(%rax), %edi
callq 0x6ebb
leaq 0x69c2(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6874(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x69b4(%rip)      # 0xda84
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x69a9(%rip)      # 0xda88
leaq 0x50(%rip), %rax        # 0x7136
leaq 0x63e3(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize
static int mouse_resize(press_arg *info) {
	xcb_get_geometry_reply_t *geom;

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

	events[XCB_ENTER_NOTIFY] = NULL;
	events[XCB_LEAVE_NOTIFY] = NULL;
	
	events[XCB_BUTTON_RELEASE] = (void (*)(xcb_generic_event_t *))resize_release;

	/*x = stack[curws].fwin->geom[GEOM_W] - info->event_x;
	y = stack[curws].fwin->geom[GEOM_H] - info->event_y;*/

	state = RESIZE;
	
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %edi
callq 0x6fc6
testl %eax, %eax
je 0x7132
xorps %xmm0, %xmm0
leaq 0x63bf(%rip), %rax      # 0xd4d0
movups %xmm0, 0x38(%rax)
leaq 0x600(%rip), %rcx       # 0x771c
movq %rcx, 0x28(%rax)
leaq 0x631d(%rip), %rax      # 0xd444
movl $0x2, (%rax)
pushq $0x1
popq %rax
jmp 0x7134
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x71d3
leaq 0x6780(%rip), %rax      # 0xd910
movl 0x14(%rax), %edi
callq 0x6ebb
leaq 0x68d1(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6783(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x114(%rax), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x68c7(%rip)      # 0xda88
leaq 0x12(%rip), %rax        # 0x71da
leaq 0x6301(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x727c
leaq 0x66dc(%rip), %rax      # 0xd910
movl 0x4(%rax), %edi
callq 0x6ebb
movl 0x8(%rbx), %eax
leaq 0x682a(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x66dc(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
subl 0x10c(%rcx), %eax
movl %eax, 0x6823(%rip)      # 0xda88
callq 0x7283
leaq 0x44(%rip), %rax        # 0x72b5
leaq 0x6258(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x7357
leaq 0x6601(%rip), %rax      # 0xd910
movl 0x1c(%rax), %edi
callq 0x6ebb
movl 0x4(%rbx), %eax
leaq 0x674f(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x6601(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
subl 0x108(%rcx), %eax
movl %eax, 0x6744(%rip)      # 0xda84
callq 0x735e
leaq 0x44(%rip), %rax        # 0x7390
leaq 0x617d(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x742d
leaq 0x6526(%rip), %rax      # 0xd910
movl 0xc(%rax), %edi
callq 0x6ebb
leaq 0x6677(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6529(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %eax
subl 0x4(%rbx), %eax
movl %eax, 0x6669(%rip)      # 0xda84
leaq 0x12(%rip), %rax        # 0x7434
leaq 0x60a7(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq