LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_unmap_event
static void handle_unmap_event(XUnmapEvent *e) {
	Client *c = find_client(e->window);

	LOG_ENTER("handle_unmap_event(window=%lx)", e->window);
	if (c) {
		if (c->ignore_unmap) {
			c->ignore_unmap--;
			LOG_DEBUG("ignored (%d ignores remaining)\n", c->ignore_unmap);
		} else {
			LOG_DEBUG("flagging client for removal\n");
			c->remove = 1;
			need_client_tidy = 1;
		}
	} else {
		LOG_DEBUG("unknown client!\n");
	}
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5287
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x526d
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x5285
movq -0x10(%rbp), %rax
movl $0x1, 0x7c(%rax)
leaq 0xa741(%rip), %rax      # 0xf9c0
movl $0x1, (%rax)
jmp 0x5289
jmp 0x5289
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_mappingnotify_event
static void handle_mappingnotify_event(XMappingEvent *e) {
	XRefreshKeyboardMapping(e);
	if (e->request == MappingKeyboard) {
		int i;
		for (i = 0; i < num_screens; i++) {
			grab_keys_for_screen(&screens[i]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34a0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x52eb
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xa6d0(%rip), %rcx      # 0xf990
cmpl (%rcx), %eax
jge 0x52e9
leaq 0xa6cd(%rip), %rax      # 0xf998
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
callq 0xa710
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52b6
jmp 0x52eb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_deinit_screen
void ewmh_deinit_screen(ScreenInfo *s) {
	XDeleteProperty(dpy, s->root, xa_net_supported);
	XDeleteProperty(dpy, s->root, xa_net_client_list);
	XDeleteProperty(dpy, s->root, xa_net_client_list_stacking);
#ifdef VWM
	XDeleteProperty(dpy, s->root, xa_net_number_of_desktops);
#endif
	XDeleteProperty(dpy, s->root, xa_net_desktop_geometry);
	XDeleteProperty(dpy, s->root, xa_net_desktop_viewport);
#ifdef VWM
	XDeleteProperty(dpy, s->root, xa_net_current_desktop);
#endif
	XDeleteProperty(dpy, s->root, xa_net_active_window);
	XDeleteProperty(dpy, s->root, xa_net_workarea);
	XDeleteProperty(dpy, s->root, xa_net_supporting_wm_check);
	XDestroyWindow(dpy, s->supporting);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x95cd(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x9443(%rip), %rdx      # 0xf808
callq 0x3240
leaq 0x95af(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x942d(%rip), %rdx      # 0xf810
callq 0x3240
leaq 0x9591(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x9417(%rip), %rdx      # 0xf818
callq 0x3240
leaq 0x9573(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x9401(%rip), %rdx      # 0xf820
callq 0x3240
leaq 0x9555(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x93eb(%rip), %rdx      # 0xf828
callq 0x3240
leaq 0x9537(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x93d5(%rip), %rdx      # 0xf830
callq 0x3240
leaq 0x9519(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x93bf(%rip), %rdx      # 0xf838
callq 0x3240
leaq 0x94fb(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x93a9(%rip), %rdx      # 0xf840
callq 0x3240
leaq 0x94dd(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x9393(%rip), %rdx      # 0xf848
callq 0x3240
leaq 0x94bf(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x937d(%rip), %rdx      # 0xf850
callq 0x3240
leaq 0x94a1(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_init_client
void ewmh_init_client(Client *c) {
	Atom allowed_actions[] = {
		xa_net_wm_action_move,
		xa_net_wm_action_maximize_horz,
		xa_net_wm_action_maximize_vert,
		xa_net_wm_action_fullscreen,
		xa_net_wm_action_change_desktop,
		xa_net_wm_action_close,
		/* nelements reduced to omit this if not possible: */
		xa_net_wm_action_resize,
	};
	int nelements = sizeof(allowed_actions) / sizeof(Atom);
	/* Omit resize element if resizing not possible: */
	if (c->max_width && c->max_width == c->min_width
			&& c->max_height && c->max_height == c->min_height)
		nelements--;
	XChangeProperty(dpy, c->window, xa_net_wm_allowed_actions,
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&allowed_actions,
			nelements);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq 0x93bd(%rip), %rax      # 0xf8d0
movq %rax, -0x40(%rbp)
movq 0x93c2(%rip), %rax      # 0xf8e0
movq %rax, -0x38(%rbp)
movq 0x93bf(%rip), %rax      # 0xf8e8
movq %rax, -0x30(%rbp)
movq 0x93bc(%rip), %rax      # 0xf8f0
movq %rax, -0x28(%rbp)
movq 0x93b9(%rip), %rax      # 0xf8f8
movq %rax, -0x20(%rbp)
movq 0x93b6(%rip), %rax      # 0xf900
movq %rax, -0x18(%rbp)
movq 0x9383(%rip), %rax      # 0xf8d8
movq %rax, -0x10(%rbp)
movl $0x7, -0x44(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x659d
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jne 0x659d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0x659d
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
jne 0x659d
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
leaq 0x93dc(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x9313(%rip), %rdx      # 0xf8c8
movl -0x44(%rbp), %eax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x40(%rbp), %r10
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3480
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list
void ewmh_set_net_client_list(ScreenInfo *s) {
	Window *windows = alloc_window_array();
	struct list *iter;
	int i = 0;
	for (iter = clients_mapping_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen == s) {
			windows[i++] = c->window;
		}
	}
	XChangeProperty(dpy, s->root, xa_net_client_list,
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6760
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x927d(%rip), %rax      # 0xf940
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6717
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6708
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x670a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x66ca
leaq 0x9262(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x90e0(%rip), %rdx      # 0xf810
movq -0x10(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3480
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: alloc_window_array
static Window *alloc_window_array(void) {
	struct list *iter;
	unsigned int count = 0;
	for (iter = clients_mapping_order; iter; iter = iter->next) {
		count++;
	}
	if (count == 0) count++;
	/* Round up to next block of 128 */
	count = (count + 127) & ~127;
	window_array = realloc(window_array, count * sizeof(Window));
	return window_array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
leaq 0x91ca(%rip), %rax      # 0xf940
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x679a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x677d
cmpl $0x0, -0xc(%rbp)
jne 0x67a9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x7f, %eax
andl $-0x80, %eax
movl %eax, -0xc(%rbp)
movq 0x915c(%rip), %rdi      # 0xf918
movl -0xc(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x3530
movq %rax, 0x9147(%rip)      # 0xf918
movq 0x9140(%rip), %rax      # 0xf918
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list_stacking
void ewmh_set_net_client_list_stacking(ScreenInfo *s) {
	Window *windows = alloc_window_array();
	struct list *iter;
	int i = 0;
	for (iter = clients_stacking_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen == s) {
			windows[i++] = c->window;
		}
	}
	XChangeProperty(dpy, s->root, xa_net_client_list_stacking,
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6760
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x9145(%rip), %rax      # 0xf948
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6857
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6848
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x684a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x680a
leaq 0x9122(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x8fa8(%rip), %rdx      # 0xf818
movq -0x10(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3480
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_active_window
void ewmh_set_net_active_window(Client *c) {
	int i;
	for (i = 0; i < num_screens; i++) {
		Window w;
		if (c && i == c->screen->screen) {
			w = c->window;
		} else {
			w = None;
		}
		XChangeProperty(dpy, screens[i].root, xa_net_active_window,
				XA_WINDOW, 32, PropModeReplace,
				(unsigned char *)&w, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x9073(%rip), %rcx      # 0xf990
cmpl (%rcx), %eax
jge 0x69ab
cmpq $0x0, -0x8(%rbp)
je 0x6948
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x6948
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6950
movq $0x0, -0x18(%rbp)
leaq 0x9029(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq 0x9037(%rip), %rax      # 0xf998
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq 0x8ec6(%rip), %rdx      # 0xf840
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x18(%rbp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x3480
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6913
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_get_net_wm_window_type
unsigned int ewmh_get_net_wm_window_type(Window w) {
	Atom *aprop;
	unsigned long nitems, i;
	unsigned int type = 0;
	if ( (aprop = get_property(w, xa_net_wm_window_type, XA_ATOM, &nitems)) ) {
		for (i = 0; i < nitems; i++) {
			if (aprop[i] == xa_net_wm_window_type_desktop)
				type |= EWMH_WINDOW_TYPE_DESKTOP;
			if (aprop[i] == xa_net_wm_window_type_dock)
				type |= EWMH_WINDOW_TYPE_DOCK;
		}
		XFree(aprop);
	}
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq 0x8e4a(%rip), %rsi      # 0xf888
movl $0x4, %edx
leaq -0x18(%rbp), %rcx
callq 0x42a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6abd
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6ab4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x8e15(%rip), %rax      # 0xf890
jne 0x6a86
movl -0x24(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x8dff(%rip), %rax      # 0xf898
jne 0x6aa4
movl -0x24(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x6aa6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6a5e
movq -0x10(%rbp), %rdi
callq 0x3220
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_wm_state
void ewmh_set_net_wm_state(Client *c) {
	Atom state[3];
	int i = 0;
	if (c->oldh)
		state[i++] = xa_net_wm_state_maximized_vert;
	if (c->oldw)
		state[i++] = xa_net_wm_state_maximized_horz;
	if (c->oldh && c->oldw)
		state[i++] = xa_net_wm_state_fullscreen;
	XChangeProperty(dpy, c->window, xa_net_wm_state,
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&state, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x6b06
movq 0x8db4(%rip), %rcx      # 0xf8a8
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movq %rcx, -0x20(%rbp,%rax,8)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x6b29
movq 0x8d99(%rip), %rcx      # 0xf8b0
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movq %rcx, -0x20(%rbp,%rax,8)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x6b56
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x6b56
movq 0x8d74(%rip), %rcx      # 0xf8b8
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movq %rcx, -0x20(%rbp,%rax,8)
leaq 0x8e23(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x8d32(%rip), %rdx      # 0xf8a0
movl -0x24(%rbp), %eax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x20(%rbp), %r10
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3480
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/list.c
// Function: list_insert_before
struct list *list_insert_before(struct list *list, struct list *before, void *data) {
	struct list *elem = list_new(data);
	struct list *iter;
	if (!elem) return list;
	if (!list) return elem;
	elem->next = before;
	if (before == list) return elem;
	for (iter = list; iter; iter = iter->next) {
		if (!iter->next || iter->next == before) {
			iter->next = elem;
			break;
		}
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6cd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6c42
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cbc
cmpq $0x0, -0x10(%rbp)
jne 0x6c53
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cbc
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x6c72
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cbc
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6cb4
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c98
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6ca5
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6cb4
jmp 0x6ca7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6c7a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/list.c
// Function: list_new
static struct list *list_new(void *data) {
	struct list *new;
	new = malloc(sizeof(struct list));
	if (!new) return NULL;
	new->next = NULL;
	new->data = data;
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x3450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6cfb
movq $0x0, -0x8(%rbp)
jmp 0x6d1a
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/list.c
// Function: list_delete
struct list *list_delete(struct list *list, void *data) {
	struct list **elemp;
	if (!data) return list;
	for (elemp = &list; *elemp; elemp = &(*elemp)->next) {
		if ((*elemp)->data == data) break;
	}
	if (*elemp) {
		struct list *elem = *elemp;
		*elemp = elem->next;
		free(elem);
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6db1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e19
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6de5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6dd6
jmp 0x6de5
jmp 0x6dd8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6db9
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6e11
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x3090
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/list.c
// Function: list_find
struct list *list_find(struct list *list, void *data) {
	struct list *elem;
	for (elem = list; elem; elem = elem->next) {
		if (elem->data == data)
			return elem;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6f12
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6f03
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f1a
jmp 0x6f05
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6ee4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/main.c
// Function: xmalloc
static void *xmalloc(size_t size) {
	void *ptr = malloc(size);
	if (!ptr) {
		/* C99 defines the 'z' printf modifier for variables of
		 * type size_t.  Fall back to casting to unsigned long. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
		LOG_ERROR("out of memory, looking for %zu bytes\n", size);
#else
		LOG_ERROR("out of memory, looking for %lu bytes\n",
				(unsigned long)size);
#endif
		exit(1);
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7316
movq 0x7d01(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5380(%rip), %rsi      # 0xc685
movb $0x0, %al
callq 0x3350
movl $0x1, %edi
callq 0x3680
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/main.c
// Function: parse_modifiers
static unsigned int parse_modifiers(char *s) {
	static struct {
		const char *name;
		unsigned int mask;
	} modifiers[9] = {
		{ "shift", ShiftMask },
		{ "lock", LockMask },
		{ "control", ControlMask },
		{ "alt", Mod1Mask },
		{ "mod1", Mod1Mask },
		{ "mod2", Mod2Mask },
		{ "mod3", Mod3Mask },
		{ "mod4", Mod4Mask },
		{ "mod5", Mod5Mask }
	};
	char *tmp = strtok(s, ",+");
	unsigned int ret = 0;
	int i;
	if (!tmp)
		return 0;
	do {
		for (i = 0; i < 9; i++) {
			if (!strcmp(modifiers[i].name, tmp))
				ret |= modifiers[i].mask;
		}
		tmp = strtok(NULL, ",+");
	} while (tmp);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x53fa(%rip), %rsi      # 0xc751
callq 0x35f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7377
movl $0x0, -0x4(%rbp)
jmp 0x73f2
jmp 0x7379
movl $0x0, -0x20(%rbp)
cmpl $0x9, -0x20(%rbp)
jge 0x73d1
movslq -0x20(%rbp), %rcx
leaq 0x829f(%rip), %rax      # 0xf630
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3330
cmpl $0x0, %eax
jne 0x73c4
movslq -0x20(%rbp), %rcx
leaq 0x827c(%rip), %rax      # 0xf630
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x73c6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7380
xorl %eax, %eax
movl %eax, %edi
leaq 0x5375(%rip), %rsi      # 0xc751
callq 0x35f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7379
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/main.c
// Function: set_app
static void set_app(const char *arg) {
	Application *new = xmalloc(sizeof(Application));
	char *tmp;
	new->res_name = new->res_class = NULL;
	new->geometry_mask = 0;
	new->is_dock = 0;
#ifdef VWM
	new->vdesk = VDESK_NONE;
#endif
	if ((tmp = strchr(arg, '/'))) {
		*(tmp++) = 0;
	}
	if (strlen(arg) > 0) {
		new->res_name = xmalloc(strlen(arg)+1);
		strcpy(new->res_name, arg);
	}
	if (tmp && strlen(tmp) > 0) {
		new->res_class = xmalloc(strlen(tmp)+1);
		strcpy(new->res_class, tmp);
	}
	applications = list_prepend(applications, new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x72d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0xfffffffe, 0x28(%rax) # imm = 0xFFFFFFFE
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x3200
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7bfc
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x31e0
cmpq $0x0, %rax
jbe 0x7c3a
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x72d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
cmpq $0x0, -0x18(%rbp)
je 0x7c81
movq -0x18(%rbp), %rdi
callq 0x31e0
cmpq $0x0, %rax
jbe 0x7c81
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x72d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3100
movq 0x7ca8(%rip), %rdi      # 0xf930
movq -0x10(%rbp), %rsi
callq 0x6d30
movq %rax, 0x7c98(%rip)      # 0xf930
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/main.c
// Function: set_app_geometry
static void set_app_geometry(const char *arg) {
	if (applications) {
		Application *app = applications->data;
		app->geometry_mask = XParseGeometry(arg,
				&app->x, &app->y, &app->width, &app->height);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x7c7c(%rip)      # 0xf930
je 0x7cf7
movq 0x7c73(%rip), %rax      # 0xf930
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x14, %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
addq $0x1c, %rcx
movq -0x10(%rbp), %r8
addq $0x20, %r8
callq 0x31b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/main.c
// Function: set_app_vdesk
static void set_app_vdesk(const char *arg) {
	unsigned int v = atoi(arg);
	if (applications && valid_vdesk(v)) {
		Application *app = applications->data;
		app->vdesk = v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3650
movl %eax, -0xc(%rbp)
cmpq $0x0, 0x7be0(%rip)      # 0xf930
je 0x7d77
cmpl $-0x1, -0xc(%rbp)
je 0x7d5e
cmpl $0x7, -0xc(%rbp)
ja 0x7d77
movq 0x7bcb(%rip), %rax      # 0xf930
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/misc.c
// Function: spawn
void spawn(const char *const cmd[]) {
	ScreenInfo *current_screen = find_current_screen();
	pid_t pid;

	if (current_screen && current_screen->display)
		putenv(current_screen->display);
	if (!(pid = fork())) {
		setsid();
		switch (fork()) {
			/* execvp()'s prototype is (char *const *) suggesting that it
			 * modifies the contents of the strings.  The prototype is this
			 * way due to SUS maintaining compatability with older code.
			 * However, execvp guarantees not to modify argv, so the following
			 * cast is valid. */
			case 0: execvp(cmd[0], (char *const *)cmd);
			default: _exit(0);
		}
	}
	if (pid > 0)
		wait(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xa6b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7de4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x7de4
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3310
callq 0x3730
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x7e18
callq 0x32d0
callq 0x3730
testl %eax, %eax
jne 0x7e11
jmp 0x7e01
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3640
xorl %edi, %edi
callq 0x30e0
cmpl $0x0, -0x14(%rbp)
jle 0x7e27
xorl %eax, %eax
movl %eax, %edi
callq 0x3710
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/misc.c
// Function: handle_xerror
int handle_xerror(Display *dsply, XErrorEvent *e) {
	Client *c;
	(void)dsply;  /* unused */

	LOG_ENTER("handle_xerror(error=%d, request=%d/%d, resourceid=%lx)", e->error_code, e->request_code, e->minor_code, e->resourceid);

	if (ignore_xerror) {
		LOG_DEBUG("ignoring...\n");
		LOG_LEAVE();
		return 0;
	}
	/* If this error actually occurred while setting up the new
	 * window, best let make_new_client() know not to bother */
	if (initialising != None && e->resourceid == initialising) {
		LOG_DEBUG("error caught while initialising window=%lx\n", initialising);
		initialising = None;
		LOG_LEAVE();
		return 0;
	}
	if (e->error_code == BadAccess && e->request_code == X_ChangeWindowAttributes) {
		LOG_ERROR("root window unavailable (maybe another wm is running?)\n");
		exit(1);
	}

	c = find_client(e->resourceid);
	if (c) {
		LOG_DEBUG("flagging client for removal\n");
		c->remove = 1;
		need_client_tidy = 1;
	} else {
		LOG_DEBUG("unknown error: not handling\n");
	}
	LOG_LEAVE();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x7b5d(%rip)      # 0xf9c4
je 0x7e75
movl $0x0, -0x4(%rbp)
jmp 0x7f27
leaq 0x7adc(%rip), %rax      # 0xf958
movq (%rax), %rax
cmpq $0x0, %rax
je 0x7eb3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x7ac4(%rip), %rcx      # 0xf958
movq (%rcx), %rcx
cmpq %rcx, %rax
jne 0x7eb3
leaq 0x7ab5(%rip), %rax      # 0xf958
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7f27
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
jne 0x7eef
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2, %eax
jne 0x7eef
movq 0x7124(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x4876(%rip), %rsi      # 0xc754
movb $0x0, %al
callq 0x3350
movl $0x1, %edi
callq 0x3680
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3880
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7f1e
movq -0x20(%rbp), %rax
movl $0x1, 0x7c(%rax)
movl $0x1, 0x7aa4(%rip)      # 0xf9c0
jmp 0x7f20
jmp 0x7f20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/misc.c
// Function: discard_enter_events
void discard_enter_events(Client *except) {
	XEvent tmp, putback_ev;
	int putback = 0;
	XSync(dpy, False);
	while (XCheckMaskEvent(dpy, EnterWindowMask, &tmp)) {
		if (tmp.xcrossing.window == except->parent) {
			memcpy(&putback_ev, &tmp, sizeof(XEvent));
			putback = 1;
		}
	}
	if (putback) {
		XPutBackEvent(dpy, &putback_ev);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18c(%rbp)
leaq 0x7a30(%rip), %rax      # 0xf980
movq (%rax), %rdi
xorl %esi, %esi
callq 0x34b0
leaq 0x7a1f(%rip), %rax      # 0xf980
movq (%rax), %rdi
movl $0x10, %esi
leaq -0xc8(%rbp), %rdx
callq 0x3600
cmpl $0x0, %eax
je 0x7faf
movq -0xa8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x7fad
leaq -0x188(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movl $0xc0, %edx
callq 0x33a0
movl $0x1, -0x18c(%rbp)
jmp 0x7f5a
cmpl $0x0, -0x18c(%rbp)
je 0x7fce
leaq 0x79c1(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq -0x188(%rbp), %rsi
callq 0x34e0
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: moveresize
void moveresize(Client *c) {
	client_raise(c);
	XMoveResizeWindow(dpy, c->parent, c->x - c->border, c->y - c->border,
			c->width, c->height);
	XMoveResizeWindow(dpy, c->window, 0, 0, c->width, c->height);
	send_config(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39f0
leaq 0x63a4(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x8(%rbp), %rax
subl 0x34(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r9d
callq 0x3260
leaq 0x6361(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x30(%rax), %r9d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3260
movq -0x8(%rbp), %rdi
callq 0x3b60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: show_info
void show_info(Client *c, unsigned int keycode) {
	XEvent ev;
	XKeyboardState keyboard;

	if (XGrabKeyboard(dpy, c->screen->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess)
		return;

	/* keyboard repeat might not have any effect, newer X servers seem to
	 * only change the keyboard control after all keys have been physically
	 * released. */
	XGetKeyboardControl(dpy, &keyboard);
	XChangeKeyboardControl(dpy, KBAutoRepeatMode, &(XKeyboardControl){.auto_repeat_mode = AutoRepeatModeOff});
#ifdef INFOBANNER
	create_info_window(c);
#else
	XGrabServer(dpy);
	draw_outline(c);
#endif
	do {
		XMaskEvent(dpy, KeyReleaseMask, &ev);
		if (ev.xkey.keycode != keycode)
			continue;
		if (XCheckIfEvent(dpy, &ev, predicate_keyrepeatpress, (XPointer)&ev)) {
			/* This is a key press event with the same time as the previous
			 * key release event. */
			continue;
		}
		break; /* escape */
	} while (1);
#ifdef INFOBANNER
	remove_info_window();
#else
	draw_outline(c);
	XUngrabServer(dpy);
#endif
	XChangeKeyboardControl(dpy, KBAutoRepeatMode, &(XKeyboardControl){.auto_repeat_mode = keyboard.global_auto_repeat});
	XUngrabKeyboard(dpy, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x6307(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %ecx
callq 0x3770
cmpl $0x0, %eax
je 0x96a7
jmp 0x97b8
leaq 0x62d2(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq -0x110(%rbp), %rsi
callq 0x30c0
leaq 0x62bc(%rip), %rax      # 0xf980
movq (%rax), %rax
movq %rax, -0x158(%rbp)
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3290
movq -0x158(%rbp), %rdi
movl $0x80, %esi
leaq -0x130(%rbp), %rdx
callq 0x30a0
movq -0x8(%rbp), %rdi
callq 0x97d0
leaq 0x6277(%rip), %rax      # 0xf980
movq (%rax), %rdi
movl $0x2, %esi
leaq -0xd0(%rbp), %rdx
callq 0x3740
movl -0x7c(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x9727
jmp 0x9750
leaq 0x6252(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq -0xd0(%rbp), %rcx
leaq 0x121(%rip), %rdx       # 0x9860
movq %rcx, %rsi
callq 0x3760
cmpl $0x0, %eax
je 0x974e
jmp 0x9750
jmp 0x9758
movb $0x1, %al
testb $0x1, %al
jne 0x9702
jmp 0x9758
callq 0x98d0
leaq 0x621c(%rip), %rax      # 0xf980
movq (%rax), %rax
movq %rax, -0x160(%rbp)
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3290
movq -0x160(%rbp), %rdi
movl -0xf8(%rbp), %eax
movl %eax, -0x134(%rbp)
movl $0x80, %esi
leaq -0x150(%rbp), %rdx
callq 0x30a0
leaq 0x61d4(%rip), %rax      # 0xf980
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36a0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: create_info_window
static void create_info_window(Client *c) {
	info_window = XCreateSimpleWindow(dpy, c->screen->root, -4, -4, 2, 2,
			0, c->screen->fg.pixel, c->screen->fg.pixel);
	XMapRaised(dpy, info_window);
	update_info_window(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x619d(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %r10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
movl $0x2, %r9d
xorl %edx, %edx
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x3590
movq %rax, 0x618f(%rip)      # 0xf9c8
leaq 0x6140(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq 0x617e(%rip), %rsi      # 0xf9c8
callq 0x3460
movq -0x8(%rbp), %rdi
callq 0xa8e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: predicate_keyrepeatpress
static Bool predicate_keyrepeatpress(Display *dummy, XEvent *ev, XPointer arg) {
	(void) dummy;
	XEvent* release_event = (XEvent*) arg;
	if (ev->type != KeyPress)
		return False;
	if (release_event->xkey.keycode != ev->xkey.keycode)
		return False;
	return release_event->xkey.time == ev->xkey.time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x988a
movl $0x0, -0x4(%rbp)
jmp 0x98be
movq -0x28(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x54(%rcx), %eax
je 0x98a3
movl $0x0, -0x4(%rbp)
jmp 0x98be
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: next
void next(void) {
	struct list *newl = list_find(clients_tab_order, current);
	Client *newc = current;
	do {
		if (newl) {
			newl = newl->next;
			if (!newl && !current)
				return;
		}
		if (!newl)
			newl = clients_tab_order;
		if (!newl)
			return;
		newc = newl->data;
		if (newc == current)
			return;
	}
#ifdef VWM
	/* NOTE: Checking against newc->screen->vdesk implies we can Alt+Tab
	 * across screen boundaries.  Is this what we want? */
	while ((!is_fixed(newc) && (newc->vdesk != newc->screen->vdesk)) || (newc->is_dock && !newc->screen->docks_visible));
#else
	while (0);
#endif
	if (!newc)
		return;
	client_show(newc);
	client_raise(newc);
	select_client(newc);
#ifdef WARP_POINTER
	setmouse(newc->window, newc->width + newc->border - 1,
			newc->height + newc->border - 1);
#endif
	discard_enter_events(newc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x5639(%rip), %rax      # 0xf938
movq (%rax), %rdi
leaq 0x5647(%rip), %rax      # 0xf950
movq (%rax), %rsi
callq 0x6ed0
movq %rax, -0x8(%rbp)
leaq 0x5634(%rip), %rax      # 0xf950
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa350
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa34e
leaq 0x560d(%rip), %rax      # 0xf950
cmpq $0x0, (%rax)
jne 0xa34e
jmp 0xa470
jmp 0xa350
cmpq $0x0, -0x8(%rbp)
jne 0xa365
leaq 0x55da(%rip), %rax      # 0xf938
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa371
jmp 0xa470
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x55c8(%rip), %rcx      # 0xf950
cmpq (%rcx), %rax
jne 0xa392
jmp 0xa470
jmp 0xa394
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0xa3b7
movq -0x10(%rbp), %rax
movl 0x74(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movb $0x1, %al
cmpl 0x40(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0xa3e0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x78(%rcx)
movb %al, -0x12(%rbp)
je 0xa3da
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x68(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa323
cmpq $0x0, -0x10(%rbp)
jne 0xa3f4
jmp 0xa470
movq -0x10(%rbp), %rdi
callq 0x39b0
movq -0x10(%rbp), %rdi
callq 0x39f0
movq -0x10(%rbp), %rdi
callq 0x3d30
leaq 0x556a(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %r10d
movq -0x10(%rbp), %rax
addl 0x34(%rax), %r10d
subl $0x1, %r10d
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x34(%rcx), %eax
subl $0x1, %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x32e0
movq -0x10(%rbp), %rdi
callq 0x7f30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: switch_vdesk
void switch_vdesk(ScreenInfo *s, unsigned int v) {
	struct list *iter;
#ifdef DEBUG
	int hidden = 0, raised = 0;
#endif

	if (v == s->vdesk)
		return;
	LOG_ENTER("switch_vdesk(screen=%d, from=%d, to=%d)", s->screen, s->vdesk, v);
	if (current && !is_fixed(current)) {
		select_client(NULL);
	}
	for (iter = clients_tab_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->vdesk == s->vdesk) {
			client_hide(c);
#ifdef DEBUG
			hidden++;
#endif
		} else if (c->vdesk == v) {
			if (!c->is_dock || s->docks_visible)
				client_show(c);
#ifdef DEBUG
			raised++;
#endif
		}
	}
	/* cache the value of the current vdesk, so that user may toggle back to it */
	s->old_vdesk = s->vdesk;
	s->vdesk = v;
	ewmh_set_net_current_desktop(s);
	LOG_DEBUG("%d hidden, %d raised\n", hidden, raised);
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0xa4a0
jmp 0xa56f
leaq 0x54a9(%rip), %rax      # 0xf950
cmpq $0x0, (%rax)
je 0xa4c6
leaq 0x549c(%rip), %rax      # 0xf950
movq (%rax), %rax
cmpl $-0x1, 0x74(%rax)
je 0xa4c6
xorl %eax, %eax
movl %eax, %edi
callq 0x3d30
leaq 0x546b(%rip), %rax      # 0xf938
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa54e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xa4f7
jmp 0xa541
movq -0x20(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0xa512
movq -0x20(%rbp), %rdi
callq 0x38f0
jmp 0xa53f
movq -0x20(%rbp), %rax
movl 0x74(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xa53d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0xa532
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0xa53b
movq -0x20(%rbp), %rdi
callq 0x39b0
jmp 0xa53d
jmp 0xa53f
jmp 0xa541
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa4d4
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x68a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: set_docks_visible
void set_docks_visible(ScreenInfo *s, int is_visible) {
	struct list *iter;

	LOG_ENTER("set_docks_visible(screen=%d, is_visible=%d)", s->screen, is_visible);
	s->docks_visible = is_visible;
	for (iter = clients_tab_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->is_dock) {
			if (is_visible) {
#ifdef VWM
				if (is_fixed(c) || (c->vdesk == s->vdesk)) {
#endif
					client_show(c);
					client_raise(c);
#ifdef VWM
				}
#endif
			} else {
				client_hide(c);
			}
		}
	}
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
leaq 0x5398(%rip), %rax      # 0xf938
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa622
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xa5ca
jmp 0xa615
movq -0x20(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0xa613
cmpl $0x0, -0xc(%rbp)
je 0xa608
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0xa5f4
movq -0x20(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0xa606
movq -0x20(%rbp), %rdi
callq 0x39b0
movq -0x20(%rbp), %rdi
callq 0x39f0
jmp 0xa611
movq -0x20(%rbp), %rdi
callq 0x38f0
jmp 0xa613
jmp 0xa615
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa5a7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: find_screen
ScreenInfo *find_screen(Window root) {
	int i;
	for (i = 0; i < num_screens; i++) {
		if (screens[i].root == root)
			return &screens[i];
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x5347(%rip), %rcx      # 0xf990
cmpl (%rcx), %eax
jge 0xa694
leaq 0x5344(%rip), %rax      # 0xf998
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xa687
leaq 0x5325(%rip), %rax      # 0xf998
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xa69c
jmp 0xa689
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa63f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: grab_keys_for_screen
void grab_keys_for_screen(ScreenInfo *s) {
	int i;
	/* Release any previous grabs */
	XUngrabKey(dpy, AnyKey, AnyModifier, s->root);
	/* Grab key combinations we're interested in */
	for (i = 0; i < NUM_GRABS; i++) {
		grab_keysym(s->root, grabmask1, keys_to_grab[i]);
	}
	for (i = 0; i < NUM_ALT_GRABS; i++) {
		grab_keysym(s->root, grabmask1 | altmask, alt_keys_to_grab[i]);
	}
	grab_keysym(s->root, grabmask2, KEY_NEXT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x525d(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x3620
movl $0x0, -0xc(%rbp)
cmpl $0x1c, -0xc(%rbp)
jge 0xa777
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4c7a(%rip), %rax      # 0xf3d0
movl (%rax), %esi
movslq -0xc(%rbp), %rcx
leaq 0x4f5d(%rip), %rax      # 0xf6c0
movq (%rax,%rcx,8), %rdx
callq 0xa7e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa741
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0xa7bd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4c3d(%rip), %rax      # 0xf3d0
movl (%rax), %esi
leaq 0x4c3c(%rip), %rax      # 0xf3d8
orl (%rax), %esi
movslq -0xc(%rbp), %rcx
leaq 0x4ff7(%rip), %rax      # 0xf7a0
movq (%rax,%rcx,8), %rdx
callq 0xa7e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa77e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4c08(%rip), %rax      # 0xf3d4
movl (%rax), %esi
movl $0xff09, %edx           # imm = 0xFF09
callq 0xa7e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/screen.c
// Function: grab_keysym
static void grab_keysym(Window w, unsigned int mask, KeySym keysym) {
	KeyCode keycode = XKeysymToKeycode(dpy, keysym);
	XGrabKey(dpy, keycode, mask, w, True,
			GrabModeAsync, GrabModeAsync);
	XGrabKey(dpy, keycode, mask|LockMask, w, True,
			GrabModeAsync, GrabModeAsync);
	if (numlockmask) {
		XGrabKey(dpy, keycode, mask|numlockmask, w, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, keycode, mask|numlockmask|LockMask, w, True,
				GrabModeAsync, GrabModeAsync);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x5186(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x33c0
movb %al, -0x19(%rbp)
leaq 0x5170(%rip), %rax      # 0xf980
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x33f0
leaq 0x5146(%rip), %rax      # 0xf980
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
orl $0x2, %edx
movq -0x8(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x33f0
leaq 0x50b9(%rip), %rax      # 0xf920
cmpl $0x0, (%rax)
je 0xa8d5
leaq 0x510d(%rip), %rax      # 0xf980
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x509c(%rip), %rax      # 0xf920
orl (%rax), %edx
movq -0x8(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x33f0
leaq 0x50da(%rip), %rax      # 0xf980
movq (%rax), %rdi
movzbl -0x19(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x5069(%rip), %rax      # 0xf920
orl (%rax), %edx
orl $0x2, %edx
movq -0x8(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0x33f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)