LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_lower
void func_lower(void *sptr, XEvent *e, unsigned flags) {
	struct client *c = sptr;
	if (!(flags & FL_CLIENT) || !c)
		return;
	(void)e;
	client_lower(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0xa67f
cmpq $0x0, -0x20(%rbp)
jne 0xa681
jmp 0xa68a
movq -0x20(%rbp), %rdi
callq 0x5d00
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: do_client_move
static void do_client_move(struct client *c) {
	if (abs(c->x) == c->border && c->oldw != 0)
		c->x = 0;
	if (abs(c->y) == c->border && c->oldh != 0)
		c->y = 0;
	if (c->width < c->min_width) {
		c->width = c->min_width;
	}
	if (c->max_width && c->width > c->max_width) {
		c->width = c->max_width;
	}
	if (c->height < c->min_height) {
		c->height = c->min_height;
	}
	if (c->max_height && c->height > c->max_height) {
		c->height = c->max_height;
	}
	client_moveresizeraise(c);
#ifdef WARP_POINTER
	setmouse(c->window, c->width + c->border - 1, c->height + c->border - 1);
#endif
	discard_enter_events(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jne 0xa8b8
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xa8b8
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jne 0xa8e4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0xa8e4
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0xa902
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x74(%rax)
je 0xa92a
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0xa92a
movq -0x8(%rbp), %rax
movl 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x70(%rcx), %eax
jge 0xa948
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0xa970
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jle 0xa970
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rdi
callq 0x6f40
movq -0x8(%rbp), %rdi
callq 0xcfa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_next
void func_next(void *sptr, XEvent *e, unsigned flags) {
	(void)sptr;
	(void)flags;
	if (e->type != KeyPress)
		return;
	XKeyEvent *xkey = (XKeyEvent *)e;
	client_select_next();
	if (XGrabKeyboard(display.dpy, xkey->root, False, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) {
		XEvent ev;
		do {
			XMaskEvent(display.dpy, KeyPressMask|KeyReleaseMask, &ev);
			if (ev.type == KeyPress && ev.xkey.keycode == xkey->keycode)
				client_select_next();
		} while (ev.type == KeyPress || ev.xkey.keycode == xkey->keycode);
		XUngrabKeyboard(display.dpy, CurrentTime);
	}
	clients_tab_order = list_to_head(clients_tab_order, current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0xa9b4
jmp 0xaa97
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x7ce0
leaq 0x83b8(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
xorl %edx, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %ecx
callq 0x45f0
cmpl $0x0, %eax
jne 0xaa71
jmp 0xa9f3
leaq 0x8386(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl $0x3, %esi
leaq -0xe0(%rbp), %rdx
callq 0x4520
cmpl $0x2, -0xe0(%rbp)
jne 0xaa2b
movl -0x8c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0xaa2b
callq 0x7ce0
jmp 0xaa2d
movb $0x1, %al
cmpl $0x2, -0xe0(%rbp)
movb %al, -0xe1(%rbp)
je 0xaa54
movl -0x8c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x54(%rcx), %eax
sete %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xa9f3
leaq 0x831b(%rip), %rax      # 0x12d80
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4460
leaq 0x82e8(%rip), %rax      # 0x12d60
movq (%rax), %rdi
leaq 0x82f6(%rip), %rax      # 0x12d78
movq (%rax), %rsi
callq 0xb020
movq %rax, %rcx
leaq 0x82cc(%rip), %rax      # 0x12d60
movq %rcx, (%rax)
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_raise
void func_raise(void *sptr, XEvent *e, unsigned flags) {
	struct client *c = sptr;
	if (!(flags & FL_CLIENT) || !c)
		return;
	(void)e;
	client_raise(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0xaacf
cmpq $0x0, -0x20(%rbp)
jne 0xaad1
jmp 0xaada
movq -0x20(%rbp), %rdi
callq 0x5cb0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/func.c
// Function: func_vdesk
void func_vdesk(void *sptr, XEvent *e, unsigned flags) {
	(void)e;
	if (flags & FL_CLIENT) {
		struct client *c = sptr;
		if (flags & FL_TOGGLE) {
			if (is_fixed(c)) {
				client_to_vdesk(c, c->screen->vdesk);
			} else {
				client_to_vdesk(c, VDESK_FIXED);
			}
		}
	} else if (flags & FL_SCREEN) {
		struct screen *current_screen = sptr;
		if (flags & FL_TOGGLE) {
			switch_vdesk(current_screen, current_screen->old_vdesk);
		} else if (flags & FL_RELATIVE) {
			if (flags & FL_DOWN) {
				if (current_screen->vdesk > 0) {
					switch_vdesk(current_screen, current_screen->vdesk - 1);
				}
			}
			if (flags & FL_UP) {
				if (current_screen->vdesk < VDESK_MAX) {
					switch_vdesk(current_screen, current_screen->vdesk + 1);
				}
			}
		} else {
			int v = flags & FL_VALUEMASK;
			switch_vdesk(current_screen, v);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0xad0a
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0xad05
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0xacf5
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x60(%rax), %esi
callq 0x6040
jmp 0xad03
movq -0x20(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6040
jmp 0xad05
jmp 0xadd7
movl -0x14(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xadd5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0xad45
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x64(%rax), %esi
callq 0xc590
jmp 0xadd3
movl -0x14(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xadba
movl -0x14(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xad7e
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jbe 0xad7c
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %esi
subl $0x1, %esi
callq 0xc590
jmp 0xad7e
movl -0x14(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xadb8
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
leaq 0x81af(%rip), %rcx      # 0x12f48
movl 0x2c(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0xadb6
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %esi
addl $0x1, %esi
callq 0xc590
jmp 0xadb8
jmp 0xadd1
movl -0x14(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xc590
jmp 0xadd3
jmp 0xadd5
jmp 0xadd7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[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);
	if (!elem)
		return list;
	if (!list)
		return elem;
	elem->next = before;
	if (before == list)
		return elem;
	for (struct list *iter = list; iter; iter = iter->next) {
		if (iter->next == before) {
			iter->next = elem;
			return list;
		}
		if (!iter->next) {
			elem->next = NULL;
			iter->next = elem;
			return list;
		}
	}
	abort();
}

// 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 0xaed0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xae15
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaeb7
cmpq $0x0, -0x10(%rbp)
jne 0xae29
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaeb7
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xae48
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaeb7
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xaeb2
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xae79
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaeb7
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xaea3
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaeb7
jmp 0xaea5
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xae50
callq 0x40f0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/list.c
// Function: list_new
static struct list *list_new(void *data) {
	struct list *new = malloc(sizeof(*new));
	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 0x41f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xaefb
movq $0x0, -0x8(%rbp)
jmp 0xaf1a
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/mati75[P]evilwm/list.c
// Function: list_delete
struct list *list_delete(struct list *list, void *data) {
	if (!data)
		return list;
	for (struct list **elemp = &list; *elemp; elemp = &(*elemp)->next) {
		if ((*elemp)->data == data) {
			struct list *elem = *elemp;
			*elemp = elem->next;
			free(elem);
			break;
		}
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xafb1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb00f
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb007
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xaff8
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 0x42e0
jmp 0xb007
jmp 0xaffa
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xafb9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/list.c
// Function: list_to_head
struct list *list_to_head(struct list *list, void *data) {
	if (!data)
		return list;
	list = list_delete(list, data);
	return list_prepend(list, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb041
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb063
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/list.c
// Function: list_to_tail
struct list *list_to_tail(struct list *list, void *data) {
	if (!data)
		return list;
	list = list_delete(list, data);
	return list_append(list, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb091
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb0b3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/list.c
// Function: list_find
struct list *list_find(struct list *list, void *data) {
	for (struct list *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 0xb102
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xb0f3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb10a
jmp 0xb0f5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb0d4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/main.c
// Function: set_bind
static void set_bind(const char *arg) {
	char *argdup = xstrdup(arg);
	if (!argdup)
		return;
	opt_bind = list_prepend(opt_bind, argdup);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd9c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb6e2
jmp 0xb6f9
movq 0x78bf(%rip), %rdi      # 0x12fa8
movq -0x10(%rbp), %rsi
callq 0xaf30
movq %rax, 0x78af(%rip)      # 0x12fa8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/main.c
// Function: set_app
static void set_app(const char *arg) {
	struct application *new = xmalloc(sizeof(struct application));
	char *tmp;
	new->res_name = new->res_class = NULL;
	new->geometry_mask = 0;
	new->is_dock = 0;
	new->vdesk = VDESK_NONE;
	if ((tmp = strchr(arg, '/'))) {
		*(tmp++) = 0;
	}
	if (*arg) {
		new->res_name = xstrdup(arg);
	}
	if (tmp && *tmp) {
		new->res_class = xstrdup(tmp);
	}
	applications = list_prepend(applications, new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0xd890
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 0x4490
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xb77c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb798
movq -0x8(%rbp), %rdi
callq 0xd9c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xb7bf
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb7bf
movq -0x18(%rbp), %rdi
callq 0xd9c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x7772(%rip), %rdi      # 0x12f38
movq -0x10(%rbp), %rsi
callq 0xaf30
movq %rax, 0x7762(%rip)      # 0x12f38
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/main.c
// Function: set_app_geometry
static void set_app_geometry(const char *arg) {
	if (applications) {
		struct 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, 0x7744(%rip)      # 0x12f38
je 0xb837
movq 0x773b(%rip), %rax      # 0x12f38
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 0x47a0
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/mati75[P]evilwm/main.c
// Function: set_app_vdesk
static void set_app_vdesk(const char *arg) {
	unsigned v = strtoul(arg, NULL, 0);
	if (applications && valid_vdesk(v)) {
		struct application *app = applications->data;
		app->vdesk = v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4730
movl %eax, -0xc(%rbp)
cmpq $0x0, 0x76a2(%rip)      # 0x12f38
je 0xb8c2
cmpl $-0x1, -0xc(%rbp)
je 0xb8a9
movl -0xc(%rbp), %eax
cmpl 0x76cd(%rip), %eax      # 0x12f74
jae 0xb8c2
movq 0x7688(%rip), %rax      # 0x12f38
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,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: screen_to_display_str
static char *screen_to_display_str(int i) {
	char *ds = DisplayString(display.dpy);
	char *dpy_str = xmalloc(20 + strlen(ds));
	strcpy(dpy_str, "DISPLAY=");
	strcat(dpy_str, ds);
	char *colon = strrchr(dpy_str, ':');
	if (!colon || display.nscreens < 2)
		return dpy_str;

	char *dot = strchr(colon, '.');
	if (!dot)
		dot = colon + strlen(colon);
	snprintf(dot, 12, ".%d", i);

	return dpy_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
leaq 0x6cfe(%rip), %rax      # 0x12d80
movq (%rax), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4300
movq %rax, %rdi
addq $0x14, %rdi
callq 0xd890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x31b7(%rip), %rsi      # 0xf26b
callq 0x4580
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0x4390
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc0ef
leaq 0x6c9a(%rip), %rax      # 0x12d80
cmpl $0x2, 0x188(%rax)
jge 0xc0f9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc153
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x4490
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc131
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4300
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0xc, %esi
leaq 0x3130(%rip), %rdx      # 0xf274
movb $0x0, %al
callq 0x40a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: screen_deinit
void screen_deinit(struct screen *s) {
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_SUPPORTED));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CLIENT_LIST_STACKING));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_NUMBER_OF_DESKTOPS));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_GEOMETRY));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_DESKTOP_VIEWPORT));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_CURRENT_DESKTOP));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_ACTIVE_WINDOW));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_WORKAREA));
	XDeleteProperty(display.dpy, s->root, X_ATOM(_NET_SUPPORTING_WM_CHECK));
	XDestroyWindow(display.dpy, s->supporting);
	free(s->monitors);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x696d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x695b(%rip), %rax      # 0x12d80
movq 0x40(%rax), %rdx
callq 0x42f0
leaq 0x694b(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6939(%rip), %rax      # 0x12d80
movq 0x48(%rax), %rdx
callq 0x42f0
leaq 0x6929(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6917(%rip), %rax      # 0x12d80
movq 0x50(%rax), %rdx
callq 0x42f0
leaq 0x6907(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x68f5(%rip), %rax      # 0x12d80
movq 0x58(%rax), %rdx
callq 0x42f0
leaq 0x68e5(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x68d3(%rip), %rax      # 0x12d80
movq 0x60(%rax), %rdx
callq 0x42f0
leaq 0x68c3(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x68b1(%rip), %rax      # 0x12d80
movq 0x68(%rax), %rdx
callq 0x42f0
leaq 0x68a1(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x688f(%rip), %rax      # 0x12d80
movq 0x70(%rax), %rdx
callq 0x42f0
leaq 0x687f(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x686d(%rip), %rax      # 0x12d80
movq 0x78(%rax), %rdx
callq 0x42f0
leaq 0x685d(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x684b(%rip), %rax      # 0x12d80
movq 0x80(%rax), %rdx
callq 0x42f0
leaq 0x6838(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6826(%rip), %rax      # 0x12d80
movq 0x88(%rax), %rdx
callq 0x42f0
leaq 0x6813(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x42e0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: switch_vdesk
void switch_vdesk(struct screen *s, unsigned v) {
#ifdef DEBUG
	int nhidden = 0, nraised = 0;
#endif

	// Sanity check vdesk number.
	if (!valid_vdesk(v))
		return;

	// Selected == current?  Do nothing.
	if (v == s->vdesk)
		return;

	LOG_ENTER("switch_vdesk(screen=%d, from=%d, to=%d)", s->screen, s->vdesk, v);

	// If current client is not fixed, deselect it.  An enter event from
	// mapping clients may select a new one.
	if (current && !is_fixed(current)) {
		select_client(NULL);
	}

	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->vdesk == s->vdesk) {
			client_hide(c);
#ifdef DEBUG
			nhidden++;
#endif
		} else if (c->vdesk == v) {
			if (!c->is_dock || s->docks_visible)
				client_show(c);
#ifdef DEBUG
			nraised++;
#endif
		}
	}

	// Store previous vdesk, so that user may toggle back to it
	s->old_vdesk = s->vdesk;

	// Update current vdesk (including EWMH properties)
	s->vdesk = v;
	ewmh_set_net_current_desktop(s);

	LOG_DEBUG("%d hidden, %d raised\n", nhidden, nraised);
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xc5b9
movl -0xc(%rbp), %eax
leaq 0x6999(%rip), %rcx      # 0x12f48
cmpl 0x2c(%rcx), %eax
jb 0xc5b9
jmp 0xc69c
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jne 0xc5ca
jmp 0xc69c
leaq 0x67a7(%rip), %rax      # 0x12d78
cmpq $0x0, (%rax)
je 0xc5f0
leaq 0x679a(%rip), %rax      # 0x12d78
movq (%rax), %rax
cmpl $-0x1, 0x20(%rax)
je 0xc5f0
xorl %eax, %eax
movl %eax, %edi
callq 0x5f40
leaq 0x6769(%rip), %rax      # 0x12d60
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc67b
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 0xc621
jmp 0xc66e
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jne 0xc63c
movq -0x20(%rbp), %rdi
callq 0x5bb0
jmp 0xc66c
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xc66a
movq -0x20(%rbp), %rax
cmpl $0x0, 0x94(%rax)
je 0xc65f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0xc668
movq -0x20(%rbp), %rdi
callq 0x5c70
jmp 0xc66a
jmp 0xc66c
jmp 0xc66e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc5fe
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
callq 0x9f70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: set_docks_visible
void set_docks_visible(struct screen *s, int is_visible) {
	LOG_ENTER("set_docks_visible(screen=%d, is_visible=%d)", s->screen, is_visible);

	s->docks_visible = is_visible;

	// Traverse client list and hide or show any docks on this screen as
	// appropriate.

	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		if (c->screen != s)
			continue;
		if (c->is_dock) {
			if (is_visible) {
				// XXX I've assumed that if you want to see
				// them, you also want them raised...
				if (is_fixed(c) || (c->vdesk == s->vdesk)) {
					client_show(c);
					client_raise(c);
				}
			} 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 0x6690(%rip), %rax      # 0x12d60
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc755
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 0xc6fa
jmp 0xc748
movq -0x20(%rbp), %rax
cmpl $0x0, 0x94(%rax)
je 0xc746
cmpl $0x0, -0xc(%rbp)
je 0xc73b
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
je 0xc727
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jne 0xc739
movq -0x20(%rbp), %rdi
callq 0x5c70
movq -0x20(%rbp), %rdi
callq 0x5cb0
jmp 0xc744
movq -0x20(%rbp), %rdi
callq 0x5bb0
jmp 0xc746
jmp 0xc748
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc6d7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: scan_clients_before_resize
void scan_clients_before_resize(struct screen *s) {
	for (struct list *iter = clients_tab_order; iter; iter = iter->next) {
		struct client *c = iter->data;
		// only handle clients on the screen being resized
		if (c->screen != s)
			continue;

		struct monitor *m = client_monitor(c, NULL);

		int mw = m->width;
		int mh = m->height;
		int cx = c->oldw ? c->oldx : c->x;
		int cy = c->oldh ? c->oldy : c->y;

		c->mon_offx = (double)(cx - m->x) / (double)mw;
		c->mon_offy = (double)(cy - m->y) / (double)mh;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65ed(%rip), %rax      # 0x12d60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc864
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xc7a4
jmp 0xc854
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xc7df
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xc7e9
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0xc805
movq -0x18(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0xc80f
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
subl (%rcx), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
subl 0x4(%rcx), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc77a
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/screen.c
// Function: find_screen
struct screen *find_screen(Window root) {
	for (int i = 0; i < display.nscreens; i++) {
		if (display.screens[i].root == root)
			return &display.screens[i];
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x6357(%rip), %rcx      # 0x12d80
cmpl 0x188(%rcx), %eax
jge 0xca80
leaq 0x6348(%rip), %rax      # 0x12d80
movq 0x190(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xca73
leaq 0x6325(%rip), %rax      # 0x12d80
movq 0x190(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xca88
jmp 0xca75
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xca1f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: spawn
void spawn(const char *const cmd[]) {
	struct screen *current_screen = find_current_screen();
	pid_t pid;

	if (current_screen && current_screen->display)
		putenv(current_screen->display);
	if (!(pid = fork())) {
		// Put first fork in a new session
		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); break;
			default: _exit(0);
		}
	}
	if (pid > 0)
		wait(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xca90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcb24
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcb24
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4480
callq 0x4690
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0xcb5c
callq 0x40b0
callq 0x4690
testl %eax, %eax
jne 0xcb53
jmp 0xcb41
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4160
jmp 0xcb5a
xorl %edi, %edi
callq 0x4240
jmp 0xcb5c
cmpl $0x0, -0x14(%rbp)
jle 0xcb6b
xorl %eax, %eax
movl %eax, %edi
callq 0x40d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: handle_xerror
int handle_xerror(Display *dsply, XErrorEvent *e) {
	struct 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);

	// Some parts of the code deliberately disable error checking.

	if (ignore_xerror) {
		LOG_DEBUG("ignoring...\n");
		LOG_LEAVE();
		return 0;
	}

	// client_manage_new() sets initialising to non-None to test if a
	// window still exists.  If we end up here, the test failed, so
	// indicate that by setting it back to None.

	if (initialising != None && e->resourceid == initialising) {
		LOG_DEBUG("error caught while initialising window=%lx\n", (unsigned long)initialising);
		initialising = None;
		LOG_LEAVE();
		return 0;
	}

	// This error is generally raised when trying to start evilwm while
	// another window manager is running.

	if (e->error_code == BadAccess && e->request_code == X_ChangeWindowAttributes) {
		LOG_ERROR("root window unavailable (maybe another wm is running?)\n");
		exit(1);
	}

	// Batching of events sometimes leads to us calling XSetInputFocus()
	// for enter events to windows that were subsequently deleted.  Ignore
	// these errors.

	if (e->request_code == X_SetInputFocus) {
		LOG_DEBUG("ignoring harmless error caused by possible race\n");
		LOG_LEAVE();
		return 0;
	}

	// For any other raised error, remove the client that triggered it from
	// management, as it's probably gone.

	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, 0x6419(%rip)      # 0x12fb0
je 0xcba5
movl $0x0, -0x4(%rbp)
jmp 0xcc6a
movq 0x640c(%rip), %rax      # 0x12fb8
cmpq $0x0, %rax
je 0xcbdd
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x63f7(%rip), %rcx      # 0x12fb8
cmpq %rcx, %rax
jne 0xcbdd
movq $0x0, 0x63e7(%rip) # 0x12fb8
movl $0x0, -0x4(%rbp)
jmp 0xcc6a
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
jne 0xcc19
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2, %eax
jne 0xcc19
movq 0x53f2(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
leaq 0x2670(%rip), %rsi      # 0xf278
movb $0x0, %al
callq 0x4700
movl $0x1, %edi
callq 0x4170
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2a, %eax
jne 0xcc2f
movl $0x0, -0x4(%rbp)
jmp 0xcc6a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5820
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcc61
movq -0x20(%rbp), %rax
movl $0x1, 0x68(%rax)
leaq 0x62c7(%rip), %rax      # 0x12f20
movl $0x1, (%rax)
jmp 0xcc63
jmp 0xcc63
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: get_pointer_root_xy
Bool get_pointer_root_xy(Window w, int *x, int *y) {
	Window root_r, child_r;
	int root_x_r, root_y_r;
	int win_x_r, win_y_r;
	unsigned mask_r;
	if (!x)
		x = &root_x_r;
	if (!y)
		y = &root_y_r;
	return XQueryPointer(display.dpy, w, &root_r, &child_r, x, y, &win_x_r, &win_y_r, &mask_r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcca3
leaq -0x2c(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xccb2
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x60c7(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x34(%rbp), %r11
leaq -0x38(%rbp), %r10
leaq -0x3c(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4610
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: get_property
void *get_property(Window w, Atom property, Atom req_type,
		   unsigned long *nitems_return) {
	Atom actual_type;
	int actual_format;
	unsigned long bytes_after;
	unsigned char *prop;
	if (XGetWindowProperty(display.dpy, w, property,
			       0L, MAXIMUM_PROPERTY_LENGTH / 4, False,
			       req_type, &actual_type, &actual_format,
			       nitems_return, &bytes_after, &prop) == Success) {
		if (actual_type == req_type)
			return (void *)prop;
		XFree(prop);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq 0x605c(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %r15
movq -0x40(%rbp), %r11
xorl %eax, %eax
movl %eax, %ecx
movl $0x400, %r8d            # imm = 0x400
xorl %r9d, %r9d
leaq -0x48(%rbp), %r14
leaq -0x4c(%rbp), %rbx
leaq -0x58(%rbp), %r10
leaq -0x60(%rbp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x41d0
cmpl $0x0, %eax
jne 0xcd98
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0xcd8f
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcda0
movq -0x60(%rbp), %rdi
callq 0x4050
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: window_normal_border
int window_normal_border(Window w) {
	int bw = option.bw;
	PropMwmHints *mprop;
	unsigned long nitems;
	if ( (mprop = get_property(w, X_ATOM(_MOTIF_WM_HINTS), X_ATOM(_MOTIF_WM_HINTS), &nitems)) ) {
		if (nitems >= PROP_MWM_HINTS_ELEMENTS
		    && (mprop->flags & MWM_HINTS_DECORATIONS)
		    && !(mprop->decorations & MWM_DECOR_ALL)
		    && !(mprop->decorations & MWM_DECOR_BORDER)) {
			bw = 0;
		}
		XFree(mprop);
	}
	return bw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6185(%rip), %rax      # 0x12f48
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5fac(%rip), %rax      # 0x12d80
movq 0x28(%rax), %rsi
leaq 0x5fa1(%rip), %rax      # 0x12d80
movq 0x28(%rax), %rdx
leaq -0x20(%rbp), %rcx
callq 0xcd00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xce42
cmpq $0x3, -0x20(%rbp)
jb 0xce39
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0xce39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xce39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
jne 0xce39
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4050
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: interruptibleXNextEvent
int interruptibleXNextEvent(XEvent *event) {
	fd_set fds;
	int rc;
	int dpy_fd = ConnectionNumber(display.dpy);
	for (;;) {
		if (XPending(display.dpy)) {
			XNextEvent(display.dpy, event);
			return 1;
		}
		FD_ZERO(&fds);
		FD_SET(dpy_fd, &fds);
		rc = select(dpy_fd + 1, &fds, NULL, NULL, NULL);
		if (rc < 0) {
			if (errno == EINTR) {
				return 0;
			} else {
				LOG_ERROR("interruptibleXNextEvent(): select()\n");
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5f1a(%rip), %rax      # 0x12d80
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x98(%rbp)
leaq 0x5f07(%rip), %rax      # 0x12d80
movq (%rax), %rdi
callq 0x4770
cmpl $0x0, %eax
je 0xcea5
leaq 0x5ef3(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x43e0
movl $0x1, -0x4(%rbp)
jmp 0xcf91
jmp 0xcea7
leaq -0x90(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq $0x10, %rax
jae 0xcef1
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0xcebf
jmp 0xcef3
movl -0x98(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x98(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movl -0x98(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x4150
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jge 0xcf8c
callq 0x44e0
cmpl $0x4, (%rax)
jne 0xcf72
movl $0x0, -0x4(%rbp)
jmp 0xcf91
movq 0x5077(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
leaq 0x232d(%rip), %rsi      # 0xf2b0
movb $0x0, %al
callq 0x4700
jmp 0xcf8c
jmp 0xce72
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/util.c
// Function: discard_enter_events
void discard_enter_events(struct client *except) {
	XEvent tmp, putback_ev;
	int putback = 0;
	XSync(display.dpy, False);
	while (XCheckMaskEvent(display.dpy, EnterWindowMask, &tmp)) {
		if (tmp.xcrossing.window == except->parent) {
			memcpy(&putback_ev, &tmp, sizeof(XEvent));
			putback = 1;
		}
	}
	if (putback) {
		XPutBackEvent(display.dpy, &putback_ev);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18c(%rbp)
leaq 0x5dc0(%rip), %rax      # 0x12d80
movq (%rax), %rdi
xorl %esi, %esi
callq 0x4510
leaq 0x5daf(%rip), %rax      # 0x12d80
movq (%rax), %rdi
movl $0x10, %esi
leaq -0xc8(%rbp), %rdx
callq 0x4440
cmpl $0x0, %eax
je 0xd01f
movq -0xa8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xd01d
leaq -0x188(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movl $0xc0, %edx
callq 0x4750
movl $0x1, -0x18c(%rbp)
jmp 0xcfca
cmpl $0x0, -0x18c(%rbp)
je 0xd03e
leaq 0x5d51(%rip), %rax      # 0x12d80
movq (%rax), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4470
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xconfig.c
// Function: xconfig_parse_line
void xconfig_parse_line(struct xconfig_option *options, const char *line) {
	// skip leading spaces
	while (isspace((int)*line))
		line++;

	// end of line or comment?
	if (*line == 0 || *line == '#')
		return;

	// from here on, work on a copy of the string
	char *linedup = xstrdup(line);

	// whitespace separates option from arguments
	char *optstr = strtok(linedup, "\t\n\v\f\r ");
	if (optstr == NULL) {
		goto done;
	}

	struct xconfig_option *opt = find_option(options, optstr);
	if (opt == NULL) {
		LOG_INFO("Ignoring unknown option `%s'\n", optstr);
		goto done;
	}

	char *arg;
	if (opt->type == XCONFIG_STR_LIST) {
		// special case: spaces here mean something
		arg = strtok(NULL, "\n\v\f\r");
		while (isspace(*arg)) {
			arg++;
		}
	} else {
		arg = strtok(NULL, "\t\n\v\f\r ");
	}

	set_option(opt, arg ? arg : "");
done:
	free(linedup);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4350
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xd08e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd060
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd0a6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0xd0ab
jmp 0xd1a4
movq -0x10(%rbp), %rdi
callq 0xd9c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2231(%rip), %rsi      # 0xf2f4
callq 0x4590
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd0d8
jmp 0xd19b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd1b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd107
movq -0x20(%rbp), %rsi
leaq 0x2200(%rip), %rdi      # 0xf2fb
movb $0x0, %al
callq 0x4060
jmp 0xd19b
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xd154
xorl %eax, %eax
movl %eax, %edi
leaq 0x21fe(%rip), %rsi      # 0xf319
callq 0x4590
movq %rax, -0x30(%rbp)
callq 0x4350
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xd152
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xd124
jmp 0xd168
xorl %eax, %eax
movl %eax, %edi
leaq 0x2195(%rip), %rsi      # 0xf2f4
callq 0x4590
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd181
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xd18e
leaq 0x1807(%rip), %rax      # 0xe98f
movq %rax, -0x40(%rbp)
jmp 0xd18e
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xd240
movq -0x18(%rbp), %rdi
callq 0x42e0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xconfig.c
// Function: find_option
static struct xconfig_option *find_option(struct xconfig_option *options,
		const char *opt) {
	for (int i = 0; options[i].type != XCONFIG_END; i++) {
		if (0 == strcmp(options[i].name, opt)) {
			return &options[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x7, (%rax)
je 0xd221
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4550
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xd214
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xd229
jmp 0xd216
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xconfig.c
// Function: set_option
static void set_option(struct xconfig_option *option, const char *arg) {
	unset_option(option);
	switch (option->type) {
		case XCONFIG_BOOL:
			*(int *)option->dest.i = 1;
			break;
		case XCONFIG_INT:
			*(int *)option->dest.i = strtol(arg, NULL, 0);
			break;
		case XCONFIG_UINT:
			*(unsigned *)option->dest.u = strtoul(arg, NULL, 0);
			break;
		case XCONFIG_STRING:
			*(char **)option->dest.s = xstrdup(arg);
			break;
		case XCONFIG_STR_LIST:
			*(char ***)option->dest.sl = split_string(arg);
			break;
		case XCONFIG_CALL_0:
			((void (*)(void))option->dest.c0)();
			break;
		case XCONFIG_CALL_1:
			((void (*)(const char *))option->dest.c1)(arg);
			break;
		default:
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd5b0
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0xd319
movq -0x18(%rbp), %rax
leaq 0x2060(%rip), %rcx      # 0xf2d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
jmp 0xd31b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4430
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
jmp 0xd31b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4730
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
jmp 0xd31b
movq -0x10(%rbp), %rdi
callq 0xd9c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0xd31b
movq -0x10(%rbp), %rdi
callq 0xd670
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0xd31b
movq -0x8(%rbp), %rax
callq *0x10(%rax)
jmp 0xd31b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0xd31b
jmp 0xd31b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xconfig.c
// Function: xconfig_parse_file
enum xconfig_result xconfig_parse_file(struct xconfig_option *options,
		const char *filename) {
	char buf[256];
	char *line;
	FILE *cfg;
	cfg = fopen(filename, "r");
	if (cfg == NULL) return XCONFIG_FILE_ERROR;

	while ((line = fgets(buf, sizeof(buf), cfg))) {
		xconfig_parse_line(options, line);
	}
	fclose(cfg);
	return XCONFIG_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xf01(%rip), %rsi       # 0xe24f
callq 0x4200
movq %rax, -0x130(%rbp)
cmpq $0x0, -0x130(%rbp)
jne 0xd36d
movl $0x3, -0x4(%rbp)
jmp 0xd3b9
jmp 0xd36f
leaq -0x120(%rbp), %rdi
movq -0x130(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x42b0
movq %rax, -0x128(%rbp)
cmpq $0x0, %rax
je 0xd3a6
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0xd050
jmp 0xd36f
movq -0x130(%rbp), %rdi
callq 0x4600
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)