LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: send_config
void send_config(Client *c) {
	XConfigureEvent ce;

	ce.type = ConfigureNotify;
	ce.event = c->window;
	ce.window = c->window;
	ce.x = c->x;
	ce.y = c->y;
	ce.width = c->width;
	ce.height = c->height;
	ce.border_width = 0;
	ce.above = None;
	ce.override_redirect = False;

	XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent *)&ce);
}

// Assembly:
subq $0x58, %rsp
movq %rsp, %r8
movl $0x16, (%r8)
movq (%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movups 0x24(%rdi), %xmm0
movups %xmm0, 0x30(%r8)
xorl %eax, %eax
movl %eax, 0x40(%r8)
movq $0x0, 0x48(%r8)
movl %eax, 0x50(%r8)
leaq 0x8bf9(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movl $0x20000, %ecx          # imm = 0x20000
xorl %edx, %edx
callq 0x3050
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: gravitate_border
void gravitate_border(Client *c, int bw) {
	int dx = 0, dy = 0;
	switch (c->win_gravity) {
	default:
	case NorthWestGravity:
		dx = bw;
		dy = bw;
		break;
	case NorthGravity:
		dy = bw;
		break;
	case NorthEastGravity:
		dx = -bw;
		dy = bw;
		break;
	case EastGravity:
		dx = -bw;
		break;
	case CenterGravity:
		break;
	case WestGravity:
		dx = bw;
		break;
	case SouthWestGravity:
		dx = bw;
		dy = -bw;
		break;
	case SouthGravity:
		dy = -bw;
		break;
	case SouthEastGravity:
		dx = -bw;
		dy = -bw;
		break;
	}
	if (c->x != 0 || c->width != DisplayWidth(dpy, c->screen->screen)) {
		c->x += dx;
	}
	if (c->y != 0 || c->height != DisplayHeight(dpy, c->screen->screen)) {
		c->y += dy;
	}
}

// Assembly:
movl 0x6c(%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x3c26
xorl %eax, %eax
leaq 0x53f5(%rip), %rdx      # 0x9004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
jmp 0x3c34
negl %esi
movl %esi, %eax
xorl %esi, %esi
jmp 0x3c34
negl %esi
movl %esi, %eax
jmp 0x3c34
movl %esi, %eax
negl %eax
jmp 0x3c34
movl %esi, %eax
negl %esi
movl 0x24(%rdi), %ecx
testl %ecx, %ecx
jne 0x3c61
movl 0x2c(%rdi), %edx
leaq 0x8b9b(%rip), %r8       # 0xc7e0
movq (%r8), %r8
movq 0xe8(%r8), %r8
movq 0x10(%rdi), %r9
movslq (%r9), %r9
shlq $0x7, %r9
cmpl 0x18(%r8,%r9), %edx
je 0x3c66
addl %eax, %ecx
movl %ecx, 0x24(%rdi)
movl 0x28(%rdi), %eax
testl %eax, %eax
jne 0x3c93
movl 0x30(%rdi), %ecx
leaq 0x8b69(%rip), %rdx      # 0xc7e0
movq (%rdx), %rdx
movq 0xe8(%rdx), %rdx
movq 0x10(%rdi), %r8
movslq (%r8), %r8
shlq $0x7, %r8
cmpl 0x1c(%rdx,%r8), %ecx
je 0x3c98
addl %esi, %eax
movl %eax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: select_client
void select_client(Client *c) {
	if (current)
		XSetWindowBorder(dpy, current->parent, current->screen->bg.pixel);
	if (c) {
		unsigned long bpixel;
#ifdef VWM
		if (is_fixed(c))
			bpixel = c->screen->fc.pixel;
		else
#endif
			bpixel = c->screen->fg.pixel;
		XSetWindowBorder(dpy, c->parent, bpixel);
		XInstallColormap(dpy, c->cmap);
		XSetInputFocus(dpy, c->window, RevertToPointerRoot, CurrentTime);
	}
	current = c;
	ewmh_set_net_active_window(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8b08(%rip), %r14      # 0xc7b0
movq (%r14), %rax
testq %rax, %rax
je 0x3ccb
leaq 0x8b29(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
movq 0x30(%rax), %rdx
callq 0x3350
testq %rbx, %rbx
je 0x3d1b
cmpl $-0x1, 0x74(%rbx)
movq 0x8(%rbx), %rsi
movl $0x48, %eax
movl $0x20, %ecx
cmoveq %rax, %rcx
movq 0x10(%rbx), %rax
movq (%rax,%rcx), %rdx
leaq 0x8aeb(%rip), %r15      # 0xc7e0
movq (%r15), %rdi
callq 0x3350
movq (%r15), %rdi
movq 0x18(%rbx), %rsi
callq 0x36d0
movq (%r15), %rdi
movq (%rbx), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3710
movq %rbx, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x58e8
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: client_to_vdesk
void client_to_vdesk(Client *c, unsigned int vdesk) {
	if (valid_vdesk(vdesk)) {
		c->vdesk = vdesk;
		if (c->vdesk == c->screen->vdesk || c->vdesk == VDESK_FIXED) {
			client_show(c);
		} else {
			client_hide(c);
		}
		ewmh_set_net_wm_desktop(c);
		select_client(current);
	}
}

// Assembly:
leal 0x1(%rsi), %eax
cmpl $0x8, %eax
ja 0x3d52
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x74(%rdi)
cmpl $-0x1, %esi
je 0x3d53
movq 0x10(%rbx), %rax
cmpl %esi, 0x40(%rax)
je 0x3d53
movq %rbx, %rdi
callq 0x39ce
jmp 0x3d5b
retq
movq %rbx, %rdi
callq 0x3a75
movq %rbx, %rdi
callq 0x598a
leaq 0x8a46(%rip), %rax      # 0xc7b0
movq (%rax), %rdi
popq %rbx
jmp 0x3c99
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: send_wm_delete
void send_wm_delete(Client *c, int kill_client) {
	int i, n, found = 0;
	Atom *protocols;

	if (!kill_client && XGetWMProtocols(dpy, c->window, &protocols, &n)) {
		for (i = 0; i < n; i++)
			if (protocols[i] == xa_wm_delete)
				found++;
		XFree(protocols);
	}
	if (found)
		send_xmessage(c->window, xa_wm_protos, xa_wm_delete);
	else
		XKillClient(dpy, c->window);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x3f23
leaq 0x88d6(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x3180
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x88b6(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x3500
testl %eax, %eax
je 0x3f03
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rdi
testq %rax, %rax
jle 0x3fc6
leaq 0x86e7(%rip), %r15      # 0xc640
movq (%r15), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
xorl %esi, %esi
cmpq %rcx, (%rdi,%rdx,8)
sete %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x3f60
callq 0x3210
testl %ebp, %ebp
je 0x3f03
movq (%rbx), %rsi
leaq 0x86b1(%rip), %rax      # 0xc638
movq (%rax), %rax
movq (%r15), %rcx
leaq 0x18(%rsp), %r8
movl $0x21, (%r8)
movq %rsi, 0x20(%r8)
movq %rax, 0x28(%r8)
movl $0x20, 0x30(%r8)
movq %rcx, 0x38(%r8)
movq $0x0, 0x40(%r8)
movq (%r14), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3050
jmp 0x3f15
callq 0x3210
jmp 0x3f03
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/client.c
// Function: set_shape
void set_shape(Client *c) {
	int bounding_shaped;
	int i, b;  unsigned int u;  /* dummies */

	if (!have_shape) return;
	/* Logic to decide if we have a shaped window cribbed from fvwm-2.5.10.
	 * Previous method (more than one rectangle returned from
	 * XShapeGetRectangles) worked _most_ of the time. */
	if (XShapeQueryExtents(dpy, c->window, &bounding_shaped, &i, &i,
				&u, &u, &b, &i, &i, &u, &u) && bounding_shaped) {
		LOG_DEBUG("%d shape extents\n", bounding_shaped);
		XShapeCombineShape(dpy, c->parent, ShapeBounding, 0, 0,
				c->window, ShapeBounding, ShapeSet);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8832(%rip), %rax      # 0xc810
cmpl $0x0, (%rax)
je 0x4045
movq %rdi, %rbx
leaq 0x87f3(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0xc(%rsp), %r9
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %rdx
movq %rcx, %r8
pushq %r9
pushq %r9
pushq %rcx
pushq %rcx
pushq %rax
pushq %r9
callq 0x31f0
addq $0x30, %rsp
testl %eax, %eax
je 0x4045
cmpl $0x0, 0x8(%rsp)
je 0x4045
movq (%r14), %rdi
movq (%rbx), %r9
movq 0x8(%rbx), %rsi
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %rax
callq 0x3540
addq $0x10, %rsp
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7232(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x70ac(%rip), %rdx      # 0xc668
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x70a1(%rip), %rdx      # 0xc670
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7096(%rip), %rdx      # 0xc678
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x708b(%rip), %rdx      # 0xc680
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7080(%rip), %rdx      # 0xc688
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7075(%rip), %rdx      # 0xc690
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x706a(%rip), %rdx      # 0xc698
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x705f(%rip), %rdx      # 0xc6a0
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7054(%rip), %rdx      # 0xc6a8
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7049(%rip), %rdx      # 0xc6b0
callq 0x3230
movq (%r14), %rdi
movq 0x10(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x38, %rsp
movq 0x70a6(%rip), %rax      # 0xc730
movq %rax, (%rsp)
movq 0x70ab(%rip), %rax      # 0xc740
movq %rax, 0x8(%rsp)
movq 0x70a7(%rip), %rax      # 0xc748
movq %rax, 0x10(%rsp)
movq 0x70a3(%rip), %rax      # 0xc750
movq %rax, 0x18(%rsp)
movq 0x709f(%rip), %rax      # 0xc758
movq %rax, 0x20(%rsp)
movq 0x709b(%rip), %rax      # 0xc760
movq %rax, 0x28(%rsp)
movq 0x7067(%rip), %rax      # 0xc738
movq %rax, 0x30(%rsp)
movl 0x50(%rdi), %eax
movl $0x7, %r10d
testl %eax, %eax
je 0x56fd
cmpl 0x48(%rdi), %eax
jne 0x56fd
movl 0x54(%rdi), %eax
testl %eax, %eax
je 0x56fd
xorl %r10d, %r10d
cmpl 0x4c(%rdi), %eax
sete %r10b
xorl $0x7, %r10d
leaq 0x70dc(%rip), %rax      # 0xc7e0
movq (%rax), %rax
movq (%rdi), %rsi
movq 0x7017(%rip), %rdx      # 0xc728
movq %rsp, %r11
movl $0x4, %ecx
movq %rax, %rdi
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
callq 0x3460
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x5808
leaq 0x6ff0(%rip), %rcx      # 0xc7a0
movq (%rcx), %rcx
xorl %r10d, %r10d
testq %rcx, %rcx
je 0x57d7
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x57d2
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
jmp 0x57b6
leaq 0x7002(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rbx), %rsi
movq 0x6e84(%rip), %rdx      # 0xc670
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x3460
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x6f90(%rip), %rax      # 0xc7a0
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq (%rax), %rax
incl %esi
testq %rax, %rax
jne 0x5815
cmpl $0x1, %esi
adcl $0x7f, %esi
andl $-0x80, %esi
movq 0x6f49(%rip), %rdi      # 0xc778
shlq $0x3, %rsi
callq 0x3510
movq %rax, 0x6f39(%rip)      # 0xc778
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x5808
leaq 0x6f57(%rip), %rcx      # 0xc7a8
movq (%rcx), %rcx
xorl %r10d, %r10d
testq %rcx, %rcx
je 0x5878
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x5873
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
jmp 0x5857
leaq 0x6f61(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rbx), %rsi
movq 0x6deb(%rip), %rdx      # 0xc678
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x3460
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6ef6(%rip), %rax      # 0xc7f0
cmpl $0x0, (%rax)
jle 0x597b
movq %rdi, %rbx
movl $0x8, %r15d
xorl %r12d, %r12d
leaq 0x6ece(%rip), %r13      # 0xc7e0
leaq 0x6edf(%rip), %rbp      # 0xc7f8
movq %rsp, %r14
testq %rbx, %rbx
je 0x5931
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpq %rax, %r12
jne 0x5931
movq (%rbx), %rax
jmp 0x5933
xorl %eax, %eax
movq %rax, (%rsp)
movq (%r13), %rdi
movq (%rbp), %rax
movq (%rax,%r15), %rsi
movq 0x6d56(%rip), %rdx      # 0xc6a0
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x3460
addq $0x10, %rsp
incq %r12
leaq 0x6e81(%rip), %rax      # 0xc7f0
movslq (%rax), %rax
addq $0x70, %r15
cmpq %rax, %r12
jl 0x591c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq 0x6d14(%rip), %rsi      # 0xc6e8
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x404d
testq %rax, %rax
je 0x5a2c
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x5a30
movq 0x6cf7(%rip), %rdx      # 0xc6f0
xorl %ebx, %ebx
movq 0x6cf6(%rip), %rsi      # 0xc6f8
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
xorl %r9d, %r9d
cmpq %rdx, %r8
sete %r9b
orl %ebx, %r9d
movl %r9d, %ebx
orl $0x2, %ebx
cmpq %rsi, %r8
cmovnel %r9d, %ebx
incq %rdi
cmpq %rdi, %rcx
jne 0x5a04
jmp 0x5a32
xorl %ebx, %ebx
jmp 0x5a3a
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x3210
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x18, %rsp
cmpl $0x0, 0x44(%rdi)
je 0x5a7d
movq 0x6cb5(%rip), %rax      # 0xc708
movq %rax, (%rsp)
cmpl $0x0, 0x40(%rdi)
je 0x5a8e
movq 0x6cac(%rip), %rax      # 0xc710
movq %rax, 0x8(%rsp)
movq 0x6ca8(%rip), %rax      # 0xc718
movq %rax, 0x10(%rsp)
movl $0x3, %r10d
jmp 0x5a99
cmpl $0x0, 0x40(%rdi)
je 0x5a96
movq 0x6c86(%rip), %rax      # 0xc710
movq %rax, (%rsp)
movl $0x1, %r10d
jmp 0x5a99
xorl %r10d, %r10d
leaq 0x6d40(%rip), %rax      # 0xc7e0
movq (%rax), %rax
movq (%rdi), %rsi
movq 0x6c53(%rip), %rdx      # 0xc700
movq %rsp, %r11
movl $0x4, %ecx
movq %rax, %rdi
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
callq 0x3460
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x3430
testq %rax, %rax
je 0x5b70
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
testq %rbx, %rbx
je 0x5b6d
movq %r14, (%rax)
cmpq %rbx, %r14
je 0x5b6d
movq %rbx, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x5b68
cmpq %r14, %rdx
jne 0x5b58
movq %rax, (%rcx)
jmp 0x5b70
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq %rdi, %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x5c03
testq %rax, %rax
je 0x5bea
cmpq %rsi, 0x8(%rax)
je 0x5bee
movq %rax, %rdi
movq %rdi, %rcx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5c03
cmpq %rsi, 0x8(%rdi)
jne 0x5bd7
jmp 0x5bf4
xorl %eax, %eax
jmp 0x5c03
movq %rsp, %rcx
movq %rax, %rdi
movq (%rdi), %rax
movq %rax, (%rcx)
callq 0x3090
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x3323(%rip), %rsi      # 0x974d
callq 0x35d0
testq %rax, %rax
je 0x6484
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x58f0(%rip), %r12      # 0xbd30
leaq 0x3306(%rip), %r14      # 0x974d
movl $0x8, %r13d
movq -0x8(%r13,%r12), %rdi
movq %r15, %rsi
callq 0x3310
testl %eax, %eax
jne 0x6463
orl (%r13,%r12), %ebx
addq $0x10, %r13
cmpq $0x98, %r13
jne 0x644d
xorl %edi, %edi
movq %r14, %rsi
callq 0x35d0
movq %rax, %r15
testq %rax, %rax
jne 0x6447
jmp 0x6486
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x63f6
movq %rax, %rbx
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
movq %rax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movq %r15, %rdi
movl $0x2f, %esi
callq 0x3200
testq %rax, %rax
je 0x64df
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x64e2
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x31e0
testq %rax, %rax
je 0x6508
incq %rax
movq %rax, %rdi
callq 0x63f6
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3100
testq %r14, %r14
je 0x6534
movq %r14, %rdi
callq 0x31e0
testq %rax, %rax
je 0x6534
incq %rax
movq %rax, %rdi
callq 0x63f6
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3100
movq 0x6255(%rip), %rdi      # 0xc790
movq %rbx, %rsi
callq 0x5b79
movq %rax, 0x6246(%rip)      # 0xc790
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x6239(%rip), %rax      # 0xc790
testq %rax, %rax
je 0x657a
pushq %rbx
movq 0x8(%rax), %rbx
leaq 0x14(%rbx), %rsi
leaq 0x18(%rbx), %rdx
leaq 0x1c(%rbx), %rcx
leaq 0x20(%rbx), %r8
callq 0x31b0
movl %eax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
callq 0x3630
movq 0x61f0(%rip), %rcx      # 0xc790
testq %rcx, %rcx
setne %dl
leal 0x1(%rax), %esi
cmpl $0x9, %esi
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x65c0
movq 0x8(%rcx), %rcx
movl %eax, 0x28(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x8052
testq %rax, %rax
je 0x65f8
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x65f8
callq 0x32f0
callq 0x3720
testl %eax, %eax
je 0x660d
jle 0x660b
xorl %edi, %edi
popq %rbx
jmp 0x3700
popq %rbx
retq
callq 0x32b0
callq 0x3720
testl %eax, %eax
jne 0x6626
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x3620
xorl %edi, %edi
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
leaq 0x6132(%rip), %r12      # 0xc7e0
movq (%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x3490
movq (%r12), %rdi
movq %rsp, %rdx
movl $0x10, %esi
callq 0x35e0
testl %eax, %eax
je 0x6725
leaq 0xc0(%rsp), %r14
movq %rsp, %r15
movq 0x20(%rsp), %rax
cmpq 0x8(%rbx), %rax
jne 0x66fb
movl $0xc0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3380
movl $0x1, %ebp
movq (%r12), %rdi
movl $0x10, %esi
movq %r15, %rdx
callq 0x35e0
testl %eax, %eax
jne 0x66db
testl %ebp, %ebp
je 0x6725
movq (%r12), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x34c0
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/new.c
// Function: get_wm_normal_hints
long get_wm_normal_hints(Client *c) {
	XSizeHints *size;
	long flags;
	long dummy;
	size = XAllocSizeHints();

	LOG_XENTER("XGetWMNormalHints(window=%lx)", c->window);
	XGetWMNormalHints(dpy, c->window, size, &dummy);
	debug_wm_normal_hints(size);
	LOG_XLEAVE();
	flags = size->flags;
	if (flags & PMinSize) {
		c->min_width = size->min_width;
		c->min_height = size->min_height;
	} else {
		c->min_width = c->min_height = 0;
	}
	if (flags & PMaxSize) {
		c->max_width = size->max_width;
		c->max_height = size->max_height;
	} else {
		c->max_width = c->max_height = 0;
	}
	if (flags & PBaseSize) {
		c->base_width = size->base_width;
		c->base_height = size->base_height;
	} else {
		c->base_width = c->min_width;
		c->base_height = c->min_height;
	}
	c->width_inc = c->height_inc = 1;
	if (flags & PResizeInc) {
		c->width_inc = size->width_inc ? size->width_inc : 1;
		c->height_inc = size->height_inc ? size->height_inc : 1;
	}
	if (!(flags & PMinSize)) {
		c->min_width = c->base_width + c->width_inc;
		c->min_height = c->base_height + c->height_inc;
	}
	if (flags & PWinGravity) {
		c->win_gravity_hint = size->win_gravity;
	} else {
		c->win_gravity_hint = NorthWestGravity;
	}
	c->win_gravity = c->win_gravity_hint;
	XFree(size);
	return flags;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3400
movq %rax, %r14
leaq 0x585a(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdx
callq 0x31c0
movq (%r14), %r15
xorl %eax, %eax
movl $0x0, %ecx
testb $0x10, %r15b
je 0x6fb1
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %eax
movl %eax, 0x4c(%rbx)
movl %ecx, 0x48(%rbx)
xorps %xmm0, %xmm0
testb $0x20, %r15b
je 0x6fc6
movsd 0x20(%r14), %xmm0
movlps %xmm0, 0x50(%rbx)
btl $0x8, %r15d
jae 0x6fd9
movl 0x40(%r14), %ecx
movl 0x44(%r14), %eax
movl %ecx, 0x60(%rbx)
movl %eax, 0x64(%rbx)
movabsq $0x100000001, %rdx      # imm = 0x100000001
movq %rdx, 0x58(%rbx)
movl $0x1, %edx
movl $0x1, %esi
testb $0x40, %r15b
je 0x7017
movl 0x28(%r14), %esi
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x58(%rbx)
movl 0x2c(%r14), %edx
cmpl $0x1, %edx
adcl $0x0, %edx
movl %edx, 0x5c(%rbx)
testb $0x10, %r15b
jne 0x7027
addl %ecx, %esi
movl %esi, 0x48(%rbx)
addl %eax, %edx
movl %edx, 0x4c(%rbx)
movl $0x1, %eax
btl $0x9, %r15d
jae 0x7037
movl 0x48(%r14), %eax
movl %eax, 0x68(%rbx)
movl %eax, 0x6c(%rbx)
movq %r14, %rdi
callq 0x3210
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x2, (%rsi)
jne 0x7772
movl 0x54(%rdx), %ecx
cmpl 0x54(%rsi), %ecx
jne 0x7772
movq 0x38(%rdx), %rcx
xorl %eax, %eax
cmpq 0x38(%rsi), %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x493e(%rip), %rbx      # 0xc798
movq (%rbx), %rdi
leaq 0x494c(%rip), %r14      # 0xc7b0
movq (%r14), %rsi
callq 0x5c6e
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
je 0x7e87
movq (%rax), %rax
movq %rax, %rsi
orq %rcx, %rsi
jne 0x7e89
jmp 0x7f26
xorl %eax, %eax
testq %rax, %rax
cmoveq %rdx, %rax
testq %rax, %rax
je 0x7f26
movq 0x8(%rax), %rbx
cmpq %rcx, %rbx
je 0x7f26
movl 0x74(%rbx), %esi
cmpl $-0x1, %esi
je 0x7eb7
movq 0x10(%rbx), %rdi
cmpl 0x40(%rdi), %esi
jne 0x7e72
cmpl $0x0, 0x78(%rbx)
je 0x7ec7
movq 0x10(%rbx), %rsi
cmpl $0x0, 0x68(%rsi)
je 0x7e72
movq %rbx, %rdi
callq 0x3a75
movq %rbx, %rdi
callq 0x3ad0
movq %rbx, %rdi
callq 0x3c99
leaq 0x48fa(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rdx
movl 0x34(%rbx), %eax
decl %eax
movl 0x2c(%rbx), %r10d
addl %eax, %r10d
addl 0x30(%rbx), %eax
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq $0x0
callq 0x32c0
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6695
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl %esi, 0x40(%rdi)
jne 0x7f34
retq
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x486c(%rip), %rax      # 0xc7b0
movq (%rax), %rax
testq %rax, %rax
je 0x7f59
cmpl $-0x1, 0x74(%rax)
je 0x7f59
xorl %edi, %edi
callq 0x3c99
leaq 0x4838(%rip), %rax      # 0xc798
movq (%rax), %r14
testq %r14, %r14
je 0x7f9b
movq 0x8(%r14), %rdi
cmpq %rbx, 0x10(%rdi)
jne 0x7f96
movl 0x74(%rdi), %eax
cmpl 0x40(%rbx), %eax
jne 0x7f81
callq 0x39ce
jmp 0x7f96
cmpl %ebp, %eax
jne 0x7f96
cmpl $0x0, 0x78(%rdi)
je 0x7f91
cmpl $0x0, 0x68(%rbx)
je 0x7f96
callq 0x3a75
movq (%r14), %r14
jmp 0x7f63
movl 0x40(%rbx), %eax
movl %eax, 0x58(%rbx)
movl %ebp, 0x40(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x58a9
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x68(%rdi)
leaq 0x47d6(%rip), %rax      # 0xc798
movq (%rax), %r12
testq %r12, %r12
je 0x801b
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r12), %r15
cmpq %r14, 0x10(%r15)
je 0x7fe5
movq (%r12), %r12
testq %r12, %r12
jne 0x7fcf
jmp 0x801b
cmpl $0x0, 0x78(%r15)
je 0x7fda
testl %ebx, %ebx
je 0x8011
movl 0x74(%r15), %eax
cmpl $-0x1, %eax
je 0x7fff
cmpl 0x40(%r14), %eax
jne 0x7fda
movq %r15, %rdi
callq 0x3a75
movq %r15, %rdi
callq 0x3ad0
jmp 0x7fda
movq %r15, %rdi
callq 0x39ce
jmp 0x7fda
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x47c2(%rip), %rax      # 0xc7f0
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x804f
leaq 0x47bb(%rip), %rax      # 0xc7f8
movq (%rax), %rax
cmpq %rdi, 0x8(%rax)
je 0x8051
addq $0x70, %rax
decq %rcx
jne 0x8040
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/screen.c
// Function: find_current_screen
ScreenInfo *find_current_screen(void) {
	Window cur_root, dw;
	int di;
	unsigned int dui;

	/* XQueryPointer is useful for getting the current pointer root */
	XQueryPointer(dpy, screens[0].root, &cur_root, &dw, &di, &di, &di, &di, &dui);
	return find_screen(cur_root);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x4782(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
leaq 0x4790(%rip), %rbx      # 0xc7f8
movq (%rbx), %rax
movq 0x8(%rax), %rsi
subq $0x8, %rsp
leaq 0x18(%rsp), %rax
leaq 0x1c(%rsp), %r8
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r8, %r9
pushq %rax
pushq %r8
pushq %r8
callq 0x3390
addq $0x20, %rsp
leaq 0x4751(%rip), %rax      # 0xc7f0
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x80be
movq 0x8(%rsp), %rdx
movq (%rbx), %rax
cmpq %rdx, 0x8(%rax)
je 0x80c0
addq $0x70, %rax
decq %rcx
jne 0x80af
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4707(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq 0x8(%rbx), %rcx
xorl %r15d, %r15d
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x3600
leaq 0x42da(%rip), %r14      # 0xc3d0
leaq 0x16e3(%rip), %r12      # 0x97e0
movq 0x8(%rbx), %rdi
movl (%r14), %esi
movq (%r15,%r12), %rdx
callq 0x8166
addq $0x8, %r15
cmpq $0xe0, %r15
jne 0x80fd
xorl %r15d, %r15d
leaq 0x42b4(%rip), %r12      # 0xc3d8
leaq 0x1795(%rip), %r13      # 0x98c0
movq 0x8(%rbx), %rdi
movl (%r12), %esi
orl (%r14), %esi
movq (%r15,%r13), %rdx
callq 0x8166
addq $0x8, %r15
cmpq $0x28, %r15
jne 0x812b
movq 0x8(%rbx), %rdi
leaq 0x4280(%rip), %rax      # 0xc3d4
movl (%rax), %esi
movl $0xff09, %edx           # imm = 0xFF09
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8166
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x4663(%rip), %r15      # 0xc7e0
movq (%r15), %rdi
movq %rdx, %rsi
callq 0x33a0
movq (%r15), %rdi
movzbl %al, %r14d
movl $0x1, %r12d
movl %r12d, (%rsp)
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33d0
movq (%r15), %rdi
movl %ebp, %edx
orl $0x2, %edx
movl %r12d, (%rsp)
movl %r14d, %esi
movq %rbx, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33d0
leaq 0x45a4(%rip), %r13      # 0xc780
movl (%r13), %edx
testl %edx, %edx
je 0x822b
movq (%r15), %rdi
orl %ebp, %edx
movl %r12d, (%rsp)
movl %r14d, %esi
movq %rbx, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33d0
movq (%r15), %rdi
orl (%r13), %ebp
orl $0x2, %ebp
movl %r12d, (%rsp)
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/xconfig.c
// Function: xconfig_parse_file
enum xconfig_result xconfig_parse_file(struct xconfig_option *options,
		const char *filename) {
	struct xconfig_option *option;
	char buf[256];
	char *line, *opt, *arg;
	FILE *cfg;
	cfg = fopen(filename, "r");
	if (cfg == NULL) return XCONFIG_FILE_ERROR;
	while ((line = fgets(buf, sizeof(buf), cfg))) {
		while (isspace((int)*line))
			line++;
		if (*line == 0 || *line == '#')
			continue;
		opt = strtok(line, "\t\n\v\f\r =");
		if (opt == NULL) continue;
		option = find_option(options, opt);
		if (option == NULL) {
			fclose(cfg);
			return XCONFIG_BAD_OPTION;
		}
		if (option->type == XCONFIG_STR_LIST) {
			/* special case: spaces here mean something */
			arg = strtok(NULL, "\n\v\f\r");
			while (isspace(*arg) || *arg == '=') {
				arg++;
			}
		} else {
			arg = strtok(NULL, "\t\n\v\f\r =");
		}
		set_option(option, arg);
	}
	fclose(cfg);
	return XCONFIG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rax
movq %rdi, %r14
leaq 0x16b2(%rip), %rsi      # 0x990c
movq %rax, %rdi
callq 0x35c0
testq %rax, %rax
je 0x8356
movq %rax, %rbx
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x32d0
testq %rax, %rax
je 0x834a
movq %rax, %rbp
callq 0x3740
movq %rax, %r15
movq %rsp, %r12
leaq 0x1672(%rip), %r13      # 0x990e
movq (%r15), %rax
decq %rbp
movsbq 0x1(%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x82a2
movzbl %cl, %eax
cmpl $0x23, %eax
je 0x832e
testl %eax, %eax
je 0x832e
movq %rbp, %rdi
movq %r13, %rsi
callq 0x35d0
testq %rax, %rax
je 0x832e
movq %r14, %rdi
movq %rax, %rsi
callq 0x8376
testq %rax, %rax
je 0x836f
movq %rax, %rbp
cmpl $0x3, (%rax)
jne 0x8319
xorl %edi, %edi
leaq 0x1624(%rip), %rsi      # 0x9916
callq 0x35d0
movq (%r15), %rcx
decq %rax
movsbq 0x1(%rax), %rdx
incq %rax
cmpq $0x3d, %rdx
je 0x82fd
movzwl (%rcx,%rdx,2), %edx
andl $0x2000, %edx           # imm = 0x2000
jne 0x82fd
jmp 0x8323
xorl %edi, %edi
movq %r13, %rsi
callq 0x35d0
movq %rbp, %rdi
movq %rax, %rsi
callq 0x83ac
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x32d0
movq %rax, %rbp
testq %rax, %rax
jne 0x829c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x31a0
jmp 0x835b
movl $0x3, %ebp
movl %ebp, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebp
jmp 0x834c
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/xconfig.c
// Function: find_option
static struct xconfig_option *find_option(struct xconfig_option *options,
		const char *opt) {
	int i;
	for (i = 0; options[i].type != XCONFIG_END; i++) {
		if (0 == strcmp(options[i].name, opt)) {
			return &options[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x6, (%rdi)
je 0x839f
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3310
testl %eax, %eax
je 0x83a1
cmpl $0x6, 0x18(%rbx)
leaq 0x18(%rbx), %rbx
jne 0x8385
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/xconfig.c
// Function: set_option
static void set_option(struct xconfig_option *option, const char *arg) {
	switch (option->type) {
		case XCONFIG_BOOL:
			*(int *)option->dest = 1;
			break;
		case XCONFIG_INT:
			*(int *)option->dest = strtol(arg, NULL, 0);
			break;
		case XCONFIG_STRING:
			*(char **)option->dest = strdup(arg);
			break;
		case XCONFIG_STR_LIST:
			*(char ***)option->dest = split_string(arg);
			break;
		case XCONFIG_CALL_0:
			((void (*)(void))option->dest)();
			break;
		case XCONFIG_CALL_1:
			((void (*)(const char *))option->dest)(arg);
			break;
		default:
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
cmpq $0x5, %rax
ja 0x85a2
movq %rsi, %rbx
movq %rdi, (%rsp)
leaq 0x1520(%rip), %rcx      # 0x98f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
jmp 0x85a2
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
movq %rbx, %rdi
callq 0x36c0
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
jmp 0x85a2
movq %rbx, %rdi
callq 0x31e0
leaq 0x1(%rax), %rdi
callq 0x3430
testq %rax, %rax
je 0x8595
movq $0x0, 0x20(%rsp)
xorl %r14d, %r14d
movq $0x0, 0x8(%rsp)
movq %rax, %rbp
movq %rax, 0x18(%rsp)
movq %rax, %r13
movzbl (%rbx), %r15d
cmpl $0x5c, %r15d
je 0x8468
testl %r15d, %r15d
jne 0x8474
jmp 0x849c
movb 0x1(%rbx), %cl
movl $0x2, %eax
testb %cl, %cl
jne 0x8490
movsbq %r15b, %r12
callq 0x3740
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
jne 0x849c
movl $0x1, %eax
movl %r15d, %ecx
addq %rax, %rbx
movb %cl, (%r13)
incq %r13
jmp 0x8457
movb $0x0, (%r13)
cmpb $0x0, (%rbp)
je 0x84bc
leal 0x1(%r14), %r15d
movq 0x20(%rsp), %rcx
cmpl %ecx, %r15d
jge 0x84c1
movq 0x8(%rsp), %rcx
jmp 0x8500
movl %r14d, %r15d
jmp 0x8512
movl %r15d, 0x14(%rsp)
movq %rbp, %r15
movslq %ecx, %rax
leaq 0x20(,%rax,8), %rsi
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rbp
callq 0x3510
testq %rax, %rax
je 0x857e
addl $0x4, %ebp
movq %rbp, 0x20(%rsp)
movq %rax, %rcx
movq %r15, %rbp
movl 0x14(%rsp), %r15d
movslq %r14d, %rax
movq %rcx, 0x8(%rsp)
movq %rbp, (%rcx,%rax,8)
incq %r13
movq %r13, %rbp
callq 0x3740
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x851d
movl %r15d, %r14d
testb %cl, %cl
jne 0x8457
testl %r15d, %r15d
je 0x858b
movslq %r15d, %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rcx,%rax,8)
jmp 0x8597
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3360
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
movl %eax, (%rcx)
jmp 0x85a2
movq %rbx, %rdi
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
testq %r12, %r12
je 0x858b
movq %r12, %rdi
callq 0x3090
movq 0x18(%rsp), %rdi
callq 0x3090
xorl %ecx, %ecx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kek[P]evilwm/xconfig.c
// Function: xconfig_parse_cli
enum xconfig_result xconfig_parse_cli(struct xconfig_option *options,
		int argc, char **argv, int *argn) {
	struct xconfig_option *option;
	int _argn;
	char *optstr;
	_argn = argn ? *argn : 1;

	while (_argn < argc) {
		if (argv[_argn][0] != '-') {
			break;
		}
		if (0 == strcmp("--", argv[_argn])) {
			_argn++;
			break;
		}
		optstr = argv[_argn]+1;
		if (*optstr == '-') optstr++;
		option = find_option(options, optstr);
		if (option == NULL) {
			if (argn) *argn = _argn;
			return XCONFIG_BAD_OPTION;
		}
		if (option->type == XCONFIG_BOOL
				|| option->type == XCONFIG_CALL_0) {
			set_option(option, NULL);
			_argn++;
			continue;
		}
		if ((_argn + 1) >= argc) {
			if (argn) *argn = _argn;
			return XCONFIG_MISSING_ARG;
		}
		set_option(option, argv[_argn+1]);
		_argn += 2;
	}
	if (argn) *argn = _argn;
	return XCONFIG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testq %rcx, %rcx
je 0x85d1
movl (%rbx), %r12d
jmp 0x85d7
movl $0x1, %r12d
cmpl %ebp, %r12d
jge 0x864f
movslq %r12d, %rax
movq (%r14,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x864f
movzbl 0x1(%rsi), %eax
subl $0x2d, %eax
jne 0x85f5
movzbl 0x2(%rsi), %eax
negl %eax
testl %eax, %eax
je 0x864c
cmpb $0x2d, 0x1(%rsi)
je 0x8606
incq %rsi
jmp 0x860a
addq $0x2, %rsi
movq %r15, %rdi
callq 0x8376
testq %rax, %rax
je 0x8668
testl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
jne 0x8629
movl $0x1, %r13d
xorl %esi, %esi
jmp 0x863f
leal 0x1(%r12), %ecx
cmpl %ebp, %ecx
jge 0x866f
movslq %ecx, %rcx
movq (%r14,%rcx,8), %rsi
movl $0x2, %r13d
movq %rax, %rdi
callq 0x83ac
addl %r13d, %r12d
jmp 0x85d7
incl %r12d
xorl %eax, %eax
testq %rbx, %rbx
je 0x8659
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x8651
movl $0x2, %eax
jmp 0x8651
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml_json.c
// Function: cat
static void cat(FILE *fp) {
  char errbuf[200];

  toml_table_t *tab = toml_parse_file(fp, errbuf, sizeof(errbuf));
  if (!tab) {
    fprintf(stderr, "ERROR: %s\n", errbuf);
    exit(1);
  }

  print_table(tab);
  printf("\n");

  toml_free(tab);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rsp, %rsi
movl $0xc8, %edx
callq 0x2f94
testq %rax, %rax
je 0x1483
movq %rax, %rbx
movq %rax, %rdi
callq 0x148b
movl $0xa, %edi
callq 0x1040
movq %rbx, %rdi
callq 0x2f8f
addq $0xd0, %rsp
popq %rbx
retq
movq %rsp, %rdi
callq 0x125d
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml_json.c
// Function: print_table
static void print_table(toml_table_t *curtab) {
  int i;
  const char *key;
  const char *raw;
  toml_array_t *arr;
  toml_table_t *tab;

  printf("{");
  for (i = 0; 0 != (key = toml_key_in(curtab, i)); i++) {

    printf("%s\"", i > 0 ? "," : "");
    print_escape_string(key);
    printf("\":");

    if (0 != (raw = toml_raw_in(curtab, key))) {
      print_raw(raw);
    } else if (0 != (arr = toml_array_in(curtab, key))) {
      print_array(arr);
    } else if (0 != (tab = toml_table_in(curtab, key))) {
      print_table(tab);
    } else {
      abort();
    }
  }
  printf("}");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7b, %edi
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3261
testq %rax, %rax
je 0x1564
movq %rax, %r12
movl $0x1, %ebp
leaq 0x4ba1(%rip), %r13      # 0x6066
leaq 0x4b96(%rip), %r14      # 0x6062
leaq 0x4b95(%rip), %r15      # 0x6068
cmpl $0x1, %ebp
movq %r13, %rsi
leaq 0x524f(%rip), %rax      # 0x672f
cmoveq %rax, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10d0
movq %r12, %rdi
callq 0x1581
movq %r15, %rdi
xorl %eax, %eax
callq 0x10d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x333c
testq %rax, %rax
je 0x151a
movq %rax, %rdi
callq 0x1620
jmp 0x154c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3394
testq %rax, %rax
je 0x1534
movq %rax, %rdi
callq 0x183b
jmp 0x154c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33db
testq %rax, %rax
je 0x157c
movq %rax, %rdi
callq 0x148b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3261
movq %rax, %r12
incl %ebp
testq %rax, %rax
jne 0x14d3
movl $0x7d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
callq 0x1050