LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./textbox.c
// Function: textbox_moveresize
void textbox_moveresize(Textbox *tb, int x, int y, int w, int h)
{
	if (tb->flags & TB_AUTOHEIGHT)
		h = tb->font->ascent + tb->font->descent;

	if (tb->flags & TB_AUTOWIDTH)
		w = tb->extents.width;

	if (x != tb->x || y != tb->y || w != tb->w || h != tb->h)
	{
		tb->x = x; tb->y = y; tb->w = MAX(1, w); tb->h = MAX(1, h);
		XMoveResizeWindow(display, tb->window, tb->x, tb->y, tb->w, tb->h);
	}
}

// Assembly:
movq (%rdi), %rax
testb $0x1, %al
je 0x449f
movq 0x28(%rdi), %r9
movl 0x4(%r9), %r8d
addl (%r9), %r8d
testb $0x2, %al
je 0x44a7
movzwl 0x70(%rdi), %ecx
movswl 0x18(%rdi), %eax
cmpl %esi, %eax
jne 0x44c9
movswl 0x1a(%rdi), %eax
cmpl %edx, %eax
jne 0x44c9
movswl 0x1c(%rdi), %eax
cmpl %eax, %ecx
jne 0x44c9
movswl 0x1e(%rdi), %eax
cmpl %eax, %r8d
jne 0x44c9
retq
pushq %rbx
movw %si, 0x18(%rdi)
movw %dx, 0x1a(%rdi)
cmpl $0x2, %ecx
movl $0x1, %r9d
cmovll %r9d, %ecx
movw %cx, 0x1c(%rdi)
cmpl $0x2, %r8d
cmovgel %r8d, %r9d
movw %r9w, 0x1e(%rdi)
movq 0xa6b9(%rip), %rax      # 0xebb0
movq 0x8(%rdi), %r11
movswl %si, %ebx
movswl %dx, %r10d
movswl %cx, %r8d
movswl %r9w, %r9d
movq %rax, %rdi
movq %r11, %rsi
movl %ebx, %edx
movl %r10d, %ecx
popq %rbx
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./textbox.c
// Function: textbox_extents
void textbox_extents(Textbox *tb)
{
	int length = strlen(tb->text) + strlen(tb->prompt);
	char *line = calloc(length + 1, sizeof(char));
	sprintf(line, "%s%s", tb->prompt, tb->text);
	XftTextExtentsUtf8(display, tb->font, (unsigned char*)line, length, &tb->extents);
	free(line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %r14
movq %r14, %rdi
callq 0x3250
movq %rax, %r15
movq 0x58(%rbx), %r12
movq %r12, %rdi
callq 0x3250
leal (%rax,%r15), %ebp
addl %r15d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3500
movq %rax, %r15
leaq 0x5e49(%rip), %rsi      # 0xa3aa
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x32d0
movq 0xa638(%rip), %rdi      # 0xebb0
movq 0x28(%rbx), %rsi
addq $0x70, %rbx
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x3520
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3220
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./textbox.c
// Function: textbox_free
void textbox_free(Textbox *tb)
{
	if (tb->flags & TB_EDITABLE)
	{
		XDestroyIC(tb->xic);
		XCloseIM(tb->xim);
	}

	if (tb->text) free(tb->text);
	if (tb->prompt) free(tb->prompt);
	if (tb->font) XftFontClose(display, tb->font);

	XDestroyWindow(display, tb->window);
	free(tb);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x8, 0x2(%rdi)
je 0x4612
movq 0x68(%rbx), %rdi
callq 0x3400
movq 0x60(%rbx), %rdi
callq 0x3680
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x4620
callq 0x3220
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x462e
callq 0x3220
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x4643
movq 0xa572(%rip), %rdi      # 0xebb0
callq 0x30a0
movq 0xa566(%rip), %rdi      # 0xebb0
movq 0x8(%rbx), %rsi
callq 0x3280
movq %rbx, %rdi
popq %rbx
jmp 0x3220
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./textbox.c
// Function: textbox_keypress
int textbox_keypress(Textbox *tb, XEvent *ev)
{
	if (!(tb->flags & TB_EDITABLE)) return 0;

	KeySym key; Status stat; char pad[32];

	int len = XmbLookupString(tb->xic, &ev->xkey, pad, sizeof(pad), &key, &stat);
	pad[len] = 0;

	switch (key)
	{
		case XK_Left      : textbox_cursor_dec(tb);   return 1;
		case XK_Right     : textbox_cursor_inc(tb);   return 1;
		case XK_Home      : textbox_cursor_home(tb);  return 1;
		case XK_End       : textbox_cursor_end(tb);   return 1;
		case XK_Delete    : textbox_cursor_del(tb);   return 1;
		case XK_BackSpace : textbox_cursor_bkspc(tb); return 1;
		case XK_Return    : return -1;
		default:
			if (!iscntrl(*pad))
			{
				textbox_insert(tb, tb->cursor, pad);
				textbox_cursor_inc(tb);
				return 1;
			}
	}
	return 0;
}

// Assembly:
xorl %eax, %eax
testb $0x8, 0x2(%rdi)
je 0x4d0f
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %r14
leaq 0xc(%rsp), %r9
movl $0x20, %ecx
movq %r14, %r8
callq 0x34f0
cltq
movb $0x0, 0x10(%rsp,%rax)
movq (%r14), %rcx
cmpq $0xff4f, %rcx           # imm = 0xFF4F
jle 0x4c36
leaq -0xff50(%rcx), %rax
cmpq $0x7, %rax
ja 0x4c57
leaq 0x53e2(%rip), %rcx      # 0xa004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw $0x0, 0x20(%rbx)
jmp 0x4d02
cmpq $0xff08, %rcx           # imm = 0xFF08
je 0x4cfa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0xff0d, %rcx           # imm = 0xFF0D
je 0x4d07
jmp 0x4c9b
cmpq $0xffff, %rcx           # imm = 0xFFFF
jne 0x4c9b
movswl 0x20(%rbx), %ebp
movq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x3250
cmpl %ebp, %eax
cmovll %eax, %ebp
xorl %ecx, %ecx
testl %ebp, %ebp
cmovgl %ebp, %ecx
leaq (%r14,%rcx), %rdi
leaq (%r14,%rcx), %rsi
incq %rsi
subl %ecx, %eax
movslq %eax, %rdx
callq 0x33a0
movq %rbx, %rdi
callq 0x451b
jmp 0x4d02
callq 0x3290
movq (%rax), %rcx
movsbq 0x10(%rsp), %rdx
xorl %eax, %eax
testb $0x2, (%rcx,%rdx,2)
jne 0x4d07
movswl 0x20(%rbx), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x49f0
movswq 0x20(%rbx), %r14
incq %r14
jmp 0x4cd4
movswq 0x20(%rbx), %r14
decq %r14
movq 0x50(%rbx), %rdi
callq 0x3250
cmpq %r14, %rax
cmovbq %rax, %r14
movw %r14w, 0x20(%rbx)
jmp 0x4d02
movq 0x50(%rbx), %rdi
callq 0x3250
movw %ax, 0x20(%rbx)
jmp 0x4d02
movq %rbx, %rdi
callq 0x4b57
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_moveresize
void menubox_moveresize(Menubox *mb, short x, short y, short w, short h)
{
	int ow = w;

	if (mb->flags & MB_AUTOHEIGHT)
		h = (mb->box_count+1) * mb->line_height + (mb->padding*2);

	if (mb->flags & MB_AUTOWIDTH)
	{
		for (uint i = 0; i < mb->box_count; i++)
			w = MAX(mb->boxes[i]->extents.width, w);
		w += (mb->padding*2);
	}

	if (mb->flags & MB_MINWIDTH)
	{
		w = MAX(ow, w);
	}

	if (x != mb->x || y != mb->y || w != mb->w || h != mb->h)
	{
		mb->x = x; mb->y = y; mb->w = MAX(1, w); mb->h = MAX(1, h);
		XMoveResizeWindow(display, mb->window, mb->x, mb->y, mb->w, mb->h);
	}
}

// Assembly:
movq (%rdi), %rax
testb $0x1, %al
jne 0x4ee8
movl %r8d, %r9d
jmp 0x4efd
movl 0x50(%rdi), %r8d
incl %r8d
imull 0x20(%rdi), %r8d
movzwl 0x22(%rdi), %r9d
leal (%r8,%r9,2), %r9d
movl %ecx, %r8d
testb $0x2, %al
je 0x4f46
movl 0x50(%rdi), %r8d
movl %ecx, %r10d
testq %r8, %r8
je 0x4f3d
pushq %rbp
pushq %r14
pushq %rbx
movq 0x58(%rdi), %r11
xorl %ebx, %ebx
movl %ecx, %r10d
movq (%r11,%rbx,8), %r14
movzwl 0x70(%r14), %ebp
movswl %r10w, %r10d
cmpl %r10d, %ebp
cmovgl %ebp, %r10d
incq %rbx
cmpq %rbx, %r8
jne 0x4f1d
popq %rbx
popq %r14
popq %rbp
movzwl 0x22(%rdi), %r8d
leal (%r10,%r8,2), %r8d
cmpw %r8w, %cx
movl %r8d, %r10d
cmovgl %ecx, %r10d
testb $0x8, %al
cmovel %r8d, %r10d
cmpw %si, 0x18(%rdi)
jne 0x4f72
cmpw %dx, 0x1a(%rdi)
jne 0x4f72
cmpw 0x1c(%rdi), %r10w
jne 0x4f72
cmpw 0x1e(%rdi), %r9w
jne 0x4f72
retq
movw %si, 0x18(%rdi)
movw %dx, 0x1a(%rdi)
cmpw $0x2, %r10w
movl $0x1, %eax
movl $0x1, %r8d
cmovgel %r10d, %r8d
movw %r8w, 0x1c(%rdi)
cmpw $0x2, %r9w
cmovll %eax, %r9d
movw %r9w, 0x1e(%rdi)
movq 0x9c08(%rip), %rax      # 0xebb0
movq 0x8(%rdi), %r11
movswl %si, %r10d
movswl %dx, %ecx
movl $0xffff, %edx           # imm = 0xFFFF
andl %edx, %r8d
andl %edx, %r9d
movq %rax, %rdi
movq %r11, %rsi
movl %r10d, %edx
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_add
void menubox_add(Menubox *mb, int id, char *text)
{
	uint slot = mb->box_count++;

	mb->boxes = (Textbox**) realloc(mb->boxes, sizeof(Textbox) * mb->box_count);
	mb->ids   = (int*)      realloc(mb->ids,   sizeof(int)     * mb->box_count);
	mb->show  = (int*)      realloc(mb->show,  sizeof(int)     * mb->box_count);
	
	mb->boxes[slot] = textbox_create(mb->window, TB_AUTOHEIGHT|TB_AUTOWIDTH,
		mb->padding, mb->line_height*(slot+1)+mb->padding, mb->w-(mb->padding*2), 0,
		mb->font, mb->fg_blur, mb->bg_blur, text, NULL);

	mb->ids[slot]   = id;
	mb->show[slot]  = 1;
	
	if (mb->flags & (MB_AUTOWIDTH|MB_AUTOHEIGHT))
		menubox_moveresize(mb, mb->x, mb->y, mb->w, mb->h);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x50(%rdi), %r15d
leal 0x1(%r15), %r12d
movl %r12d, 0x50(%rdi)
movq 0x58(%rdi), %rdi
movq %r12, %rsi
shlq $0x7, %rsi
callq 0x3640
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movl 0x50(%rbx), %esi
shlq $0x2, %rsi
callq 0x3640
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movl 0x50(%rbx), %esi
shlq $0x2, %rsi
callq 0x3640
movq %rax, 0x68(%rbx)
movq 0x8(%rbx), %rdi
movswl 0x22(%rbx), %edx
imulw 0x20(%rbx), %r12w
addl %edx, %r12d
movl 0x1c(%rbx), %eax
subl %edx, %eax
subl %edx, %eax
subq $0x8, %rsp
movswl %r12w, %ecx
movswl %ax, %r8d
movl $0x3, %esi
xorl %r9d, %r9d
pushq $0x0
pushq %r14
pushq 0x48(%rbx)
pushq 0x40(%rbx)
pushq 0x28(%rbx)
callq 0x41e6
addq $0x30, %rsp
movq 0x58(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x60(%rbx), %rax
movl %ebp, (%rax,%r15,4)
movq 0x68(%rbx), %rax
movl $0x1, (%rax,%r15,4)
testb $0x3, (%rbx)
je 0x50a8
movswl 0x18(%rbx), %esi
movswl 0x1a(%rbx), %edx
movswl 0x1c(%rbx), %ecx
movswl 0x1e(%rbx), %r8d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4edc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_draw
void menubox_draw(Menubox *mb)
{
	textbox_draw(mb->input);
	int filter = strlen(mb->input->text) > 0;

	for (uint i = 0, n = 0; i < mb->box_count; i++)
	{
		if (!filter || mb->show[i])
		{
			textbox_font(mb->boxes[i], mb->font, mb->box_active == i ? mb->fg_focus: mb->fg_blur, mb->box_active == i ? mb->bg_focus: mb->bg_blur);
			textbox_moveresize(mb->boxes[i], mb->padding, mb->line_height*(n+1)+mb->padding, mb->w-(mb->padding*2), 0);
			textbox_show(mb->boxes[i]);	
			textbox_draw(mb->boxes[i]);
			n++;
		}
		else
		{
			textbox_hide(mb->boxes[i]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x465c
cmpl $0x0, 0x50(%rbx)
je 0x51f1
movq 0x70(%rbx), %rax
movq 0x50(%rax), %rax
movb (%rax), %bpl
xorl %r14d, %r14d
xorl %r15d, %r15d
testb %bpl, %bpl
je 0x5151
movq 0x68(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
je 0x51ca
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq 0x28(%rbx), %rsi
movl 0x54(%rbx), %eax
xorl %ecx, %ecx
cmpq %rax, %r14
setne %cl
shll $0x4, %ecx
movq 0x30(%rcx,%rbx), %rdx
movq 0x38(%rcx,%rbx), %rcx
callq 0x438a
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
movswl 0x22(%rbx), %esi
movswl 0x20(%rbx), %edx
incl %r15d
imull %r15d, %edx
addl %esi, %edx
movswl 0x1c(%rbx), %ecx
subl %esi, %ecx
subl %esi, %ecx
xorl %r8d, %r8d
callq 0x448d
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x99fe(%rip), %rdi      # 0xebb0
movq 0x8(%rax), %rsi
callq 0x3350
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x465c
jmp 0x51e2
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x99d7(%rip), %rdi      # 0xebb0
movq 0x8(%rax), %rsi
callq 0x32a0
incq %r14
movl 0x50(%rbx), %eax
cmpq %rax, %r14
jb 0x5141
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_free
void menubox_free(Menubox *mb)
{
	for (uint i = 0; i < mb->box_count; i++)
		textbox_free(mb->boxes[i]);
	free(mb->boxes);
	free(mb->ids);
	free(mb->show);
	textbox_free(mb->input);
	XDestroyWindow(display, mb->window);
	free(mb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x50(%rdi)
je 0x5260
xorl %r14d, %r14d
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x45f6
incq %r14
movl 0x50(%rbx), %eax
cmpq %rax, %r14
jb 0x5248
movq 0x58(%rbx), %rdi
callq 0x3220
movq 0x60(%rbx), %rdi
callq 0x3220
movq 0x68(%rbx), %rdi
callq 0x3220
movq 0x70(%rbx), %rdi
callq 0x45f6
movq 0x9925(%rip), %rdi      # 0xebb0
movq 0x8(%rbx), %rsi
callq 0x3280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3220
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_filter
void menubox_filter(Menubox *mb)
{
	int filter = strlen(mb->input->text) > 0;
	char *pattern = strdup(mb->input->text);
	for (char *p = pattern; *p; *p = tolower(*p), p++);

	for (int i = 0; i < mb->box_count; i++)
	{
		char *subject = strdup(mb->boxes[i]->text);
		for (char *p = subject; *p; *p = tolower(*p), p++);
		mb->show[i] = (!filter || regex_match(pattern, subject));
		free(subject);
	}
	free(pattern);

	// active entry maybe filtered. step backward
	while (!mb->show[mb->box_active] && mb->box_active > 0)
		mb->box_active--;

	// active entry maybe filtered. step forward
	while (!mb->show[mb->box_active] && mb->box_active < mb->box_count-1)
		mb->box_active++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq 0x50(%rax), %rdi
movb (%rdi), %bpl
callq 0x3430
movq %rax, %r14
movb (%rax), %r15b
testb %r15b, %r15b
je 0x52ed
callq 0x34e0
movq (%rax), %rax
leaq 0x1(%r14), %rcx
movsbq %r15b, %rdx
movb (%rax,%rdx,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %r15b
incq %rcx
testb %r15b, %r15b
jne 0x52d8
cmpl $0x0, 0x50(%rbx)
je 0x536b
xorl %r13d, %r13d
movq 0x58(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x50(%rax), %rdi
callq 0x3430
movq %rax, %r15
movb (%rax), %r12b
testb %r12b, %r12b
je 0x5333
callq 0x34e0
leaq 0x1(%r15), %rcx
movq (%rax), %rdx
movsbq %r12b, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %r12b
incq %rcx
testb %r12b, %r12b
jne 0x531b
testb %bpl, %bpl
je 0x5345
movq %r14, %rdi
movq %r15, %rsi
callq 0x4123
jmp 0x534a
movl $0x1, %eax
movq 0x68(%rbx), %r12
movl %eax, (%r12,%r13,4)
movq %r15, %rdi
callq 0x3220
incq %r13
movl 0x50(%rbx), %r15d
cmpq %r15, %r13
jb 0x52f6
decl %r15d
jmp 0x5375
movq 0x68(%rbx), %r12
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x3220
movl 0x54(%rbx), %eax
movl (%r12,%rax,4), %edx
testq %rax, %rax
je 0x53ab
testl %edx, %edx
jne 0x53ab
movq %rax, %rsi
decq %rsi
decl %eax
movl %eax, 0x54(%rbx)
movl %esi, %ecx
movl (%r12,%rcx,4), %edx
testl %esi, %esi
je 0x53ae
decq %rsi
testl %edx, %edx
je 0x5393
jmp 0x53ae
movq %rax, %rcx
cmpl %r15d, %eax
jae 0x53d0
testl %edx, %edx
jne 0x53d0
movl %r15d, %eax
incq %rcx
movl %ecx, 0x54(%rbx)
cmpq %rax, %rcx
jae 0x53d0
cmpl $0x0, (%r12,%rcx,4)
leaq 0x1(%rcx), %rcx
je 0x53bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menubox.c
// Function: menubox_keypress
int menubox_keypress(Menubox *mb, XEvent *ev)
{
	KeySym key; Status stat; char pad[32];

	int len = XmbLookupString(mb->input->xic, &ev->xkey, pad, sizeof(pad), &key, &stat);
	pad[len] = 0;

	int rc = 0;

	switch (key)
	{
		case XK_Up     : { menubox_key_up(mb);   rc = 1; break; }
		case XK_Down   : { menubox_key_down(mb); rc = 1; break; }
		case XK_Escape : { rc = -2; break; }
		case XK_Return : { rc = -1; break; }
		default: rc = textbox_keypress(mb->input, ev);
	}

	menubox_filter(mb);
	return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq 0x68(%rax), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r9
movl $0x20, %ecx
movq %r15, %r8
callq 0x34f0
cltq
movb $0x0, 0x10(%rsp,%rax)
movq (%r15), %rax
cmpq $0xff51, %rax           # imm = 0xFF51
jg 0x545b
cmpq $0xff0d, %rax           # imm = 0xFF0D
je 0x548b
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
cmpq $0xff1b, %rax           # imm = 0xFF1B
je 0x54a8
jmp 0x547b
cmpq $0xff54, %rax           # imm = 0xFF54
je 0x5492
cmpq $0xff52, %rax           # imm = 0xFF52
jne 0x547b
movl 0x54(%rbx), %eax
movl $0x1, %ebp
testl %eax, %eax
je 0x54a8
decl %eax
jmp 0x54a5
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x4bc4
movl %eax, %ebp
jmp 0x54a8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x54a8
movl 0x50(%rbx), %ecx
movl 0x54(%rbx), %eax
decl %ecx
movl $0x1, %ebp
cmpl %ecx, %eax
jae 0x54a8
incl %eax
movl %eax, 0x54(%rbx)
movq %rbx, %rdi
callq 0x52a3
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./action.c
// Function: action_move_direction
void action_move_direction(void *data, int num, Client *cli)
{
	if (!cli) return;
	client_place_spot(cli, spot_choose_by_direction(cli->spot, cli->monitor, num), cli->monitor, 1);
	client_raise_family(cli);
	current_spot = cli->spot; current_mon = cli->monitor;
	spot_warp_pointer(cli->spot, cli->monitor);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdx, %rdx
je 0x5555
movl %esi, %edx
movl 0x118(%rbx), %edi
movswl 0x100(%rbx), %ebp
movl %ebp, %esi
callq 0x7d11
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x6c47
movq %rbx, %rdi
callq 0x70f4
movq 0x118(%rbx), %rdi
movw %di, 0x9d0c(%rip)       # 0xf248
movswl 0x100(%rbx), %esi
movw %si, 0x9d00(%rip)       # 0xf24a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7b08
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./action.c
// Function: action_raise_nth
void action_raise_nth(void *data, int num, Client *cli)
{
	if (!cli) return;
	int i, n = 0; Client *c;
	for_windows(i, c) if (c->manage && c->spot == cli->spot && c->monitor == cli->monitor && num == n++)
		{ client_activate(c); break; }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x55cb
movq %rdx, %rbx
movl %esi, %ebp
callq 0x604f
movswq 0x9829(%rip), %rax      # 0xeda0
testq %rax, %rax
jle 0x55cb
xorl %ecx, %ecx
leaq 0x981b(%rip), %rdx      # 0xeda0
xorl %esi, %esi
movq 0x8(%rdx,%rcx,8), %r14
testq %r14, %r14
je 0x55c3
cmpw $0x0, 0x104(%r14)
je 0x55c3
movq 0x118(%r14), %rdi
cmpq 0x118(%rbx), %rdi
jne 0x55c3
movzwl 0x100(%r14), %edi
cmpw 0x100(%rbx), %di
jne 0x55c3
cmpl %ebp, %esi
je 0x55d0
incl %esi
incq %rcx
cmpq %rcx, %rax
jne 0x5587
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x70f4
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x72e5
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./action.c
// Function: action_cycle
void action_cycle(void *data, int num, Client *cli)
{
	if (!cli) return;
	STACK_INIT(order);
	if (spot_stack_clients(cli->spot, cli->monitor, &order) > 1)
	{
		int i; Client *c = NULL;
		for_stack_rev(&order, i, c) if (c->manage && c->transient == None && c->window != cli->window)
		{
			client_activate(c);
			break;
		}
	}
}

// Assembly:
testq %rdx, %rdx
je 0x566d
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, %rbx
movq %rsp, %r14
movl $0x408, %edx            # imm = 0x408
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movl 0x118(%rbx), %edi
movswl 0x100(%rbx), %esi
movq %r14, %rdx
callq 0x7e01
cmpl $0x2, %eax
jl 0x5663
movswq (%rsp), %rax
testq %rax, %rax
jle 0x5663
incq %rax
movq -0x8(%rsp,%rax,8), %r14
testq %r14, %r14
je 0x565a
cmpw $0x0, 0x104(%r14)
je 0x565a
cmpq $0x0, 0x90(%r14)
jne 0x565a
movq (%r14), %rcx
cmpq (%rbx), %rcx
jne 0x566e
decq %rax
cmpq $0x1, %rax
ja 0x5633
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x70f4
movq %r14, %rdi
callq 0x72e5
jmp 0x5663
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./action.c
// Function: action_fullscreen
void action_fullscreen(void *data, int num, Client *cli)
{
	if (!cli) return;

	unsigned long spot;
	if (cli->full && GETPROP_LONG(cli->window, atoms[XOAT_SPOT], &spot, 1))
		cli->spot = spot;

	SETPROP_LONG(cli->window, atoms[XOAT_SPOT], &cli->spot, 1);
	client_toggle_state(cli, atoms[_NET_WM_STATE_FULLSCREEN]);
	client_place_spot(cli, cli->full ? SPOT1: cli->spot, cli->monitor, 1);
	client_update_border(cli);
	client_raise_family(cli);
}

// Assembly:
testq %rdx, %rdx
je 0x57a2
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpw $0x0, 0x10a(%rdx)
je 0x5723
movq (%rbx), %rdi
movq 0x95bb(%rip), %rsi      # 0xeca0
leaq 0x9ac4(%rip), %rdx      # 0xf1b0
leaq 0x9ac5(%rip), %rcx      # 0xf1b8
movq %rsp, %r8
movl $0x8, %r9d
callq 0x5d60
testl %eax, %eax
je 0x5723
cmpq $0x6, 0x9aa3(%rip)      # 0xf1b0
jne 0x5723
cmpl $0x0, 0x9aa2(%rip)      # 0xf1b8
je 0x5723
movq (%rsp), %rax
movq %rax, 0x118(%rbx)
movq 0x9486(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq 0x956c(%rip), %rdx      # 0xeca0
leaq 0x118(%rbx), %r14
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x35d0
addq $0x10, %rsp
movq 0x95eb(%rip), %rsi      # 0xed48
movq %rbx, %rdi
callq 0x6a36
movl $0x1, %esi
cmpw $0x0, 0x10a(%rbx)
jne 0x5777
movl (%r14), %esi
movswl 0x100(%rbx), %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x6c47
movq %rbx, %rdi
callq 0x6afa
movq %rbx, %rdi
callq 0x70f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./action.c
// Function: action_maximize
void action_maximize(void *data, int num, Client *cli)
{
	if (!cli) return;
	cli->max = !cli->max;
	SETPROP_LONG(cli->window, atoms[XOAT_MAXIMIZE], &cli->max, 1);
	client_place_spot(cli, cli->spot, cli->monitor, 1);
}

// Assembly:
testq %rdx, %rdx
je 0x5883
pushq %rbx
movq %rdx, %rbx
leaq 0x120(%rdx), %rax
xorl %ecx, %ecx
cmpq $0x0, 0x120(%rdx)
sete %cl
movq %rcx, 0x120(%rdx)
movq 0x936c(%rip), %rdi      # 0xebb0
movq (%rdx), %rsi
movq 0x946a(%rip), %rdx      # 0xecb8
movl $0x6, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x35d0
addq $0x10, %rsp
movl 0x118(%rbx), %esi
movswl 0x100(%rbx), %edx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
jmp 0x6c47
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/xoat.c
// Function: exec_cmd
void exec_cmd(char *cmd)
{
	signal(SIGCHLD, catch_exit);
	if (!cmd || !cmd[0] || fork()) return;
	setsid();
	EXECSH(cmd);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq -0x23(%rip), %rsi       # 0x58c4
movl $0x11, %edi
callq 0x3380
testq %rbx, %rbx
je 0x5904
cmpb $0x0, (%rbx)
je 0x5904
callq 0x3610
testl %eax, %eax
je 0x5906
popq %rbx
retq
callq 0x3090
leaq 0x4aaa(%rip), %rdi      # 0xa3bc
leaq 0x4aa8(%rip), %rsi      # 0xa3c1
leaq 0x4aa4(%rip), %rdx      # 0xa3c4
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3190
movl $0x1, %edi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./window.c
// Function: window_get_prop
int window_get_prop(Window w, Atom prop, Atom *type, int *items, void *buffer, int bytes)
{
	memset(buffer, 0, bytes);
	int format; unsigned long nitems, nbytes; unsigned char *ret = NULL;
	if (XGetWindowProperty(display, w, prop, 0, bytes/4, False, AnyPropertyType, type,
		&format, &nitems, &nbytes, &ret) == Success && ret && *type != None && format)
	{
		if (format ==  8) memmove(buffer, ret, MIN(bytes, nitems));
		if (format == 16) memmove(buffer, ret, MIN(bytes, nitems * sizeof(short)));
		if (format == 32) memmove(buffer, ret, MIN(bytes, nitems * sizeof(long)));
		*items = (int)nitems; XFree(ret);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movslq %r9d, %r15
xorl %r12d, %r12d
movq %r8, 0x10(%rsp)
movq %r8, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3070
leaq 0x28(%rsp), %r14
movq %r12, (%r14)
movq 0x8e0d(%rip), %rdi      # 0xebb0
leal 0x3(%r15), %eax
testl %r15d, %r15d
cmovnsl %r15d, %eax
sarl $0x2, %eax
movslq %eax, %r8
leaq 0x30(%rsp), %rax
leaq 0x20(%rsp), %r10
leaq 0xc(%rsp), %r11
movq %rbx, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %r14
pushq %rax
pushq %r10
pushq %r11
pushq %r13
pushq %r12
callq 0x3120
addq $0x30, %rsp
testl %eax, %eax
sete %al
movq (%r14), %rbp
testq %rbp, %rbp
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5e60
cmpq $0x0, (%r13)
setne %cl
movl 0xc(%rsp), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x5e60
movq 0x20(%rsp), %rbx
movq %rbx, %rcx
cmpl $0x8, %eax
je 0x5e34
cmpl $0x20, %eax
je 0x5e2c
cmpl $0x10, %eax
jne 0x5e4b
leaq (%rbx,%rbx), %rcx
jmp 0x5e34
leaq (,%rbx,8), %rcx
cmpq %r15, %rcx
cmovbq %rcx, %r15
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x33a0
movq 0x18(%rsp), %rax
movl %ebx, (%rax)
movq %rbp, %rdi
callq 0x3050
movl $0x1, %r12d
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./window.c
// Function: window_get_text_prop
char* window_get_text_prop(Window w, Atom atom)
{
	XTextProperty prop; char *res = NULL;
	char **list = NULL; int count;
	if (XGetTextProperty(display, w, &prop, atom) && prop.value && prop.nitems)
	{
		if (prop.encoding == XA_STRING)
		{
			res = malloc(strlen((char*)prop.value)+1);
			strcpy(res, (char*)prop.value);
		}
		else
		if (XmbTextPropertyToTextList(display, &prop, &list, &count) >= Success && count > 0 && *list)
		{
			res = malloc(strlen(*list)+1);
			strcpy(res, *list);
			XFreeStringList(list);
		}
	}
	if (prop.value) XFree(prop.value);
	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rsi
movq $0x0, 0x8(%rsp)
movq 0x8d1f(%rip), %rdi      # 0xebb0
leaq 0x10(%rsp), %rdx
callq 0x3270
xorl %ebx, %ebx
testl %eax, %eax
je 0x5f48
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x5f48
cmpq $0x0, 0x28(%rsp)
je 0x5f48
cmpq $0x1f, 0x18(%rsp)
jne 0x5ee8
movq %r14, %rdi
callq 0x3250
leaq 0x1(%rax), %rdi
callq 0x3150
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3480
jmp 0x5f48
movq 0x8cc1(%rip), %rdi      # 0xebb0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x31c0
xorl %ebx, %ebx
testl %eax, %eax
js 0x5f48
cmpl $0x0, 0x4(%rsp)
jle 0x5f48
movq 0x8(%rsp), %r14
movq (%r14), %r15
testq %r15, %r15
je 0x5f46
movq %r15, %rdi
callq 0x3250
leaq 0x1(%rax), %rdi
callq 0x3150
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3480
movq %r14, %rdi
callq 0x34a0
jmp 0x5f48
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5f57
callq 0x3050
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./window.c
// Function: window_get_name
char* window_get_name(Window w)
{
	char *name = NULL, *tmp = NULL;
	if (!(name = window_get_text_prop(w, atoms[_NET_WM_NAME])))
		if (XFetchName(display, w, &tmp))
			name = strdup(tmp);
	if (tmp) XFree(tmp);
	return name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq $0x0, (%rsp)
movq 0x8d76(%rip), %rsi      # 0xecf0
callq 0x5e72
movq %rax, %rbx
testq %rax, %rax
jne 0x5fbf
movq 0x8c22(%rip), %rdi      # 0xebb0
movq %rsp, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3510
movq (%rbx), %r14
testl %eax, %eax
je 0x5fb0
movq %r14, %rdi
callq 0x3430
movq %rax, %rbx
jmp 0x5fb2
xorl %ebx, %ebx
testq %r14, %r14
je 0x5fbf
movq %r14, %rdi
callq 0x3050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./window.c
// Function: window_send_clientmessage
int window_send_clientmessage(Window target, Window subject, Atom atom, unsigned long protocol, unsigned long mask)
{
	XEvent e;
	e.xclient.type         = ClientMessage;
	e.xclient.message_type = atom;
	e.xclient.window       = subject;
	e.xclient.data.l[0]    = protocol;
	e.xclient.data.l[1]    = latest_action;
	e.xclient.send_event   = True;
	e.xclient.format       = 32;
	int r = XSendEvent(display, target, False, mask, &e) ?1:0;
	XFlush(display);
	return r;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movq %r8, %r9
movq %rdi, %rax
movq %rsp, %r8
movl $0x21, (%r8)
movq %rdx, 0x28(%r8)
movq %rsi, 0x20(%r8)
movq %rcx, 0x38(%r8)
movq 0x8da3(%rip), %rcx      # 0xed98
movq %rcx, 0x40(%r8)
movl $0x1, 0x10(%r8)
movl $0x20, 0x30(%r8)
movq 0x8ba0(%rip), %rdi      # 0xebb0
movq %rax, %rsi
xorl %edx, %edx
movq %r9, %rcx
callq 0x3440
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movq 0x8b85(%rip), %rdi      # 0xebb0
callq 0x3410
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./window.c
// Function: query_windows
void query_windows()
{
	unsigned int nwins; int i; Window w1, w2, *wins; Client *c;
	if (windows.depth || !(XQueryTree(display, root, &w1, &w2, &wins, &nwins) && wins))
		return;
	for (i = nwins-1; i > -1 && windows.depth < STACK; i--)
	{
		if ((c = window_build_client(wins[i])) && c->visible)
		{
			windows.clients[windows.depth] = c;
			windows.windows[windows.depth++] = wins[i];
		}
		else client_free(c);
	}
	XFree(wins);
}

// Assembly:
cmpw $0x0, 0x8d49(%rip)      # 0xeda0
je 0x605a
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x8b46(%rip), %rdi      # 0xebb0
movq 0x9137(%rip), %rsi      # 0xf1a8
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %rbx
leaq 0xc(%rsp), %r9
movq %rbx, %r8
callq 0x36a0
testl %eax, %eax
setne %al
movq (%rbx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x613b
movl 0xc(%rsp), %eax
decl %eax
js 0x6136
cmpw $0x3f, 0x8ce8(%rip)     # 0xeda0
jg 0x6136
movl %eax, %r14d
leaq 0x8cdc(%rip), %r15      # 0xeda0
movq (%rsp), %rax
movq (%rax,%r14,8), %rdi
callq 0x6145
testq %rax, %rax
je 0x6120
movq %rax, %rbx
cmpw $0x0, 0x102(%rax)
je 0x610c
movswq 0x8cb5(%rip), %rax      # 0xeda0
movq %rbx, 0x8(%r15,%rax,8)
movq (%rsp), %rcx
movq (%rcx,%r14,8), %rcx
leal 0x1(%rax), %edx
movw %dx, 0x8c9e(%rip)       # 0xeda0
movq %rcx, 0x208(%r15,%rax,8)
jmp 0x6120
movq 0x128(%rbx), %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3220
testq %r14, %r14
jle 0x6132
decq %r14
cmpw $0x40, 0x8c70(%rip)     # 0xeda0
jl 0x60c4
movq (%rsp), %rdi
callq 0x3050
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./ewmh.c
// Function: ewmh_client_list
void ewmh_client_list()
{
	int i; Client *c; STACK_INIT(wins);
	for_windows_rev(i, c) if (c->manage)
		wins.windows[wins.depth++] = c->window;
	SETPROP_WIND(root, atoms[_NET_CLIENT_LIST_STACKING], wins.windows, wins.depth);
	// hack for now, since we dont track window mapping history
	SETPROP_WIND(root, atoms[_NET_CLIENT_LIST], wins.windows, wins.depth);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsp, %rdi
xorl %ebx, %ebx
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
callq 0x604f
movswq 0x8458(%rip), %rax      # 0xeda0
testq %rax, %rax
jle 0x6990
leaq 0x844c(%rip), %rcx      # 0xeda0
leaq (%rcx,%rax,8), %rcx
incq %rax
xorl %ebx, %ebx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x6983
cmpw $0x0, 0x104(%rdx)
je 0x6983
movq (%rdx), %rdx
movswq %bx, %rsi
leal 0x1(%rbx), %edi
movq %rdx, 0x208(%rsp,%rsi,8)
movl %edi, %ebx
decq %rax
addq $-0x8, %rcx
cmpq $0x1, %rax
ja 0x695d
leaq 0x208(%rsp), %r14
movw %bx, -0x208(%r14)
movq 0x8209(%rip), %rdi      # 0xebb0
movq 0x87fa(%rip), %rsi      # 0xf1a8
movq 0x8323(%rip), %rdx      # 0xecd8
movswl %bx, %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r14
callq 0x35d0
addq $0x10, %rsp
movq 0x81d7(%rip), %rdi      # 0xebb0
movq 0x87c8(%rip), %rsi      # 0xf1a8
movq 0x82f9(%rip), %rdx      # 0xece0
movswl -0x208(%r14), %eax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r14
callq 0x35d0
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_toggle_state
int client_toggle_state(Client *c, Atom state)
{
	int i, j, rc = 0;
	for (i = 0, j = 0; i < ATOMLIST && c->states[i]; i++, j++)
	{
		if (c->states[i] == state) i++;
		c->states[j] = c->states[i];
	}
	if (i == j && j < ATOMLIST)
	{
		c->states[j++] = state;
		rc = 1;
	}
	SETPROP_ATOM(c->window, atoms[_NET_WM_STATE], c->states, j);
	if (state == atoms[_NET_WM_STATE_FULLSCREEN])        c->full   = rc;
	if (state == atoms[_NET_WM_STATE_DEMANDS_ATTENTION]) c->urgent = rc;
	return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8(%rdi), %rax
xorl %r10d, %r10d
xorl %ecx, %ecx
movslq %ecx, %rdx
movq (%rax,%rdx,8), %rdx
testq %rdx, %rdx
je 0x6a83
xorl %esi, %esi
cmpq %r14, %rdx
sete %sil
leal (%rcx,%rsi), %edx
movslq %edx, %rdx
movq 0xa8(%rbx,%rdx,8), %rdi
movq %rdi, 0xa8(%rbx,%r10,8)
addl %esi, %ecx
incl %ecx
incq %r10
cmpl $0x9, %edx
jl 0x6a4c
cmpl %r10d, %ecx
setne %dl
cmpl $0xa, %r10d
setae %sil
xorl %ebp, %ebp
orb %dl, %sil
jne 0x6aa8
movl %ecx, %edx
incl %ecx
movq %r14, (%rax,%rdx,8)
movl $0x1, %ebp
movl %ecx, %r10d
movq 0x8101(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq 0x8287(%rip), %rdx      # 0xed40
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x35d0
addq $0x10, %rsp
cmpq %r14, 0x826e(%rip)      # 0xed48
jne 0x6ae3
movw %bp, 0x10a(%rbx)
cmpq %r14, 0x8276(%rip)      # 0xed60
jne 0x6af3
movw %bp, 0x108(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_update_border
void client_update_border(Client *c)
{
	XColor color; Colormap map = DefaultColormap(display, DefaultScreen(display));
	char *colorname = c->window == current ? settings.border_focus: (c->urgent ? settings.border_urgent: settings.border_blur);
	XSetWindowBorder(display, c->window, XAllocNamedColor(display, map, colorname, &color, &color) ? color.pixel: None);
	XSetWindowBorderWidth(display, c->window, c->full ? 0: settings.border);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x80a1(%rip), %r14      # 0xebb0
movq 0xe8(%r14), %rax
movslq 0xe0(%r14), %rcx
shlq $0x7, %rcx
movq 0x50(%rax,%rcx), %rsi
movq (%rdi), %r15
cmpq 0x8088(%rip), %r15      # 0xebb8
jne 0x6b3b
movq 0x8697(%rip), %rdx      # 0xf1d0
jmp 0x6b57
xorl %eax, %eax
cmpw $0x0, 0x108(%rbx)
setne %al
leaq 0x8671(%rip), %rcx      # 0xf1c0
shll $0x4, %eax
movq 0x8(%rax,%rcx), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rcx, %r8
callq 0x31a0
xorl %r12d, %r12d
testl %eax, %eax
je 0x6b75
movq 0x8(%rsp), %rdx
jmp 0x6b77
xorl %edx, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3260
movq 0x8027(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
cmpw $0x0, 0x10a(%rbx)
jne 0x6b9d
movl 0x8623(%rip), %r12d     # 0xf1c0
movl %r12d, %edx
callq 0x34c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_send_wm_protocol
int client_send_wm_protocol(Client *c, Atom protocol)
{
	Atom protocols[ATOMLIST]; int i, n;
	if ((n = GETPROP_ATOM(c->window, atoms[WM_PROTOCOLS], protocols, ATOMLIST)))
		for (i = 0; i < n; i++) if (protocols[i] == protocol)
			return window_send_clientmessage(c->window, c->window, atoms[WM_PROTOCOLS], protocol, NoEventMask);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x81c8(%rip), %rsi      # 0xed90
leaq 0x85e1(%rip), %rdx      # 0xf1b0
leaq 0x85e2(%rip), %rcx      # 0xf1b8
movq %rsp, %r8
movl $0x50, %r9d
callq 0x5d60
testl %eax, %eax
setne %cl
cmpq $0x4, 0x85bf(%rip)      # 0xf1b0
sete %dl
movl 0x85be(%rip), %eax      # 0xf1b8
testl %eax, %eax
setg %sil
andb %dl, %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x6c1e
movl %eax, %eax
xorl %ecx, %ecx
cmpq %rbx, (%rsp,%rcx,8)
je 0x6c28
incq %rcx
cmpq %rcx, %rax
jne 0x6c10
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
movq 0x815e(%rip), %rdx      # 0xed90
movq %rdi, %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x5fca
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_stack_family
void client_stack_family(Client *c, Stack *raise)
{
	int i; Client *o, *self = NULL;
	for_windows(i, o)
	{
		if (o->manage && o->visible && o->transient == c->window)
			client_stack_family(o, raise);
		else
		if (o->visible && o->window == c->window)
			self = o;
	}
	if (self)
	{
		raise->clients[raise->depth] = self;
		raise->windows[raise->depth++] = self->window;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x604f
movzwl 0x7d43(%rip), %eax      # 0xeda0
testw %ax, %ax
jle 0x70ea
xorl %r12d, %r12d
leaq 0x7d30(%rip), %r13      # 0xeda0
xorl %r15d, %r15d
movq 0x8(%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x70bf
cmpw $0x0, 0x104(%rdi)
movzwl 0x102(%rdi), %ecx
je 0x70b0
testw %cx, %cx
je 0x70bf
movq 0x90(%rdi), %rcx
cmpq (%r14), %rcx
jne 0x70b5
movq %rbx, %rsi
callq 0x7042
movzwl 0x7cf2(%rip), %eax      # 0xeda0
jmp 0x70bf
testw %cx, %cx
je 0x70bf
movq (%rdi), %rcx
cmpq (%r14), %rcx
cmoveq %rdi, %r15
incq %r12
movswq %ax, %rcx
cmpq %rcx, %r12
jl 0x7073
testq %r15, %r15
je 0x70ea
movswq (%rbx), %rax
movq %r15, 0x8(%rbx,%rax,8)
movq (%r15), %rcx
leal 0x1(%rax), %edx
movw %dx, (%rbx)
movq %rcx, 0x208(%rbx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_raise_family
void client_raise_family(Client *c)
{
	if (!c) return;
	int i; Client *o; STACK_INIT(raise); STACK_INIT(family);

	for_windows(i, o)
	{
		if (o->type == atoms[_NET_WM_WINDOW_TYPE_DOCK])
			client_stack_family(o, &raise);
		if (o->above && c->spot != SPOT3 && o->spot == SPOT3)
			client_stack_family(o, &raise);
	}

	while (c->transient && (o = window_build_client(c->transient)) && o->manage)
		c = family.clients[family.depth++] = o;

	client_stack_family(c, &raise);

	if (!c->full && settings.title)
	{
		// raise spot's title bar in case some other fullscreen or max v/h window has obscured
		Monitor *m = &monitors[c->monitor];
		raise.windows[raise.depth] = m->bars[c->spot]->window;
		raise.clients[raise.depth] = NULL;
		raise.depth++;
	}

	XRaiseWindow(display, raise.windows[0]);
	XRestackWindows(display, raise.windows, raise.depth);

	STACK_FREE(&family);
}

// Assembly:
testq %rdi, %rdi
je 0x72dc
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
leaq 0x408(%rsp), %rdi
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
callq 0x604f
cmpw $0x0, 0x7c60(%rip)      # 0xeda0
jle 0x71ae
xorl %r12d, %r12d
leaq 0x7c54(%rip), %r13      # 0xeda0
movq %rsp, %r14
movq 0x8(%r13,%r12,8), %r15
testq %r15, %r15
je 0x719e
movq 0xa0(%r15), %rax
cmpq 0x7bb9(%rip), %rax      # 0xed20
jne 0x7174
movq %r15, %rdi
movq %r14, %rsi
callq 0x7042
cmpw $0x0, 0x116(%r15)
je 0x719e
cmpq $0x3, 0x118(%rbx)
je 0x719e
cmpq $0x3, 0x118(%r15)
jne 0x719e
movq %r15, %rdi
movq %r14, %rsi
callq 0x7042
incq %r12
movswq 0x7bf7(%rip), %rax      # 0xeda0
cmpq %rax, %r12
jl 0x714f
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x720b
callq 0x6145
testq %rax, %rax
je 0x720b
xorl %ecx, %ecx
movq %rbx, %rdx
movl %ecx, %r15d
cmpw $0x0, 0x104(%rax)
je 0x72dd
movq %rax, %rbx
movswq %r15w, %rax
movq %rbx, 0x410(%rsp,%rax,8)
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x7206
callq 0x6145
leal 0x1(%r15), %ecx
movq %rbx, %rdx
testq %rax, %rax
jne 0x71c9
incl %r15d
jmp 0x720e
xorl %r15d, %r15d
movw %r15w, 0x408(%rsp)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7042
cmpw $0x0, 0x10a(%rbx)
movzwl (%r14), %r14d
jne 0x7281
cmpq $0x0, 0x7fad(%rip)      # 0xf1e8
je 0x7281
movswq %r14w, %r14
movswq 0x100(%rbx), %rax
movq 0x118(%rbx), %rcx
leaq (%rax,%rax,8), %rax
leaq 0x7965(%rip), %rdx      # 0xebc0
leaq (%rdx,%rax,8), %rax
movq 0x28(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x208(%rsp,%r14,8)
movq $0x0, 0x8(%rsp,%r14,8)
incl %r14d
movw %r14w, (%rsp)
movq 0x7928(%rip), %rdi      # 0xebb0
leaq 0x208(%rsp), %rbx
movq (%rbx), %rsi
callq 0x3110
movq 0x7911(%rip), %rdi      # 0xebb0
movswl %r14w, %edx
movq %rbx, %rsi
callq 0x32e0
testw %r15w, %r15w
je 0x72cc
decl %r15d
movswq %r15w, %r15
movq 0x410(%rsp,%r15,8), %rdi
callq 0x6901
addw $-0x1, %r15w
jb 0x72b4
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
jmp 0x720e
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./client.c
// Function: client_set_focus
void client_set_focus(Client *c)
{
	if (!c || !c->visible || c->window == current) return;
	Client *o; Window old = current;

	current      = c->window;
	current_spot = c->spot;
	current_mon  = c->monitor;

	if (old && (o = window_build_client(old)))
	{
		client_update_border(o);
		client_free(o);
	}
	client_send_wm_protocol(c, atoms[WM_TAKE_FOCUS]);
	XSetInputFocus(display, c->input ? c->window: PointerRoot, RevertToPointerRoot, CurrentTime);
	SETPROP_WIND(root, atoms[_NET_ACTIVE_WINDOW], &c->window, 1);
	client_update_border(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x730a
movq %rdi, %rbx
cmpw $0x0, 0x102(%rdi)
je 0x730a
movq (%rbx), %rax
movq 0x78b3(%rip), %rdi      # 0xebb8
cmpq %rdi, %rax
jne 0x7312
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x789f(%rip)      # 0xebb8
movzwl 0x118(%rbx), %eax
movw %ax, 0x7f21(%rip)       # 0xf248
movzwl 0x100(%rbx), %eax
movw %ax, 0x7f15(%rip)       # 0xf24a
testq %rdi, %rdi
je 0x7363
callq 0x6145
testq %rax, %rax
je 0x7363
movq %rax, %r14
movq %rax, %rdi
callq 0x6afa
movq 0x128(%r14), %rdi
callq 0x3220
movq %r14, %rdi
callq 0x3220
movq 0x7a1e(%rip), %rsi      # 0xed88
movq %rbx, %rdi
callq 0x6bb1
movq 0x7837(%rip), %rdi      # 0xebb0
cmpw $0x0, 0x106(%rbx)
je 0x7388
movq (%rbx), %rsi
jmp 0x738d
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x33f0
movq 0x7810(%rip), %rdi      # 0xebb0
movq 0x7e01(%rip), %rsi      # 0xf1a8
movq 0x791a(%rip), %rdx      # 0xecc8
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rbx
callq 0x35d0
addq $0x10, %rsp
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6afa
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menu.c
// Function: menu_close
void menu_close()
{
	if (menu->mb)
	{
		menubox_free(menu->mb);
		menu->mb = NULL;

		for (int i = 0; i < sizeof(menu->items)/sizeof(MenuMap); i++)
		{
			free(menu->items[i].name);
			menu->items[i].name = NULL;
		}
	}
}

// Assembly:
pushq %rbx
movq 0x7e37(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x745d
callq 0x5238
movq 0x7e1f(%rip), %rax      # 0xf240
movq $0x0, 0x648(%rax)
movl $0x10, %ebx
movq 0x7e08(%rip), %rax      # 0xf240
movq (%rax,%rbx), %rdi
callq 0x3220
movq 0x7df8(%rip), %rax      # 0xf240
movq $0x0, (%rax,%rbx)
addq $0x10, %rbx
cmpq $0x650, %rbx            # imm = 0x650
jne 0x7431
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menu.c
// Function: menu_select
void menu_select()
{
	int id; Client *c;

	if (menu->mb)
	{
		id = menubox_get_id(menu->mb);
		if (id >= 0 && (c = window_build_client(menu->items[id].window)) && c)
		{
			if (c->manage)
				client_activate(c);
			client_free(c);
		}
		else
		if (strlen(menu->mb->input->text))
		{
			exec_cmd(menu->mb->input->text);
		}
		menu_close();
	}
}

// Assembly:
movq 0x7dda(%rip), %rcx      # 0xf240
movq 0x648(%rcx), %rax
testq %rax, %rax
je 0x74d3
pushq %rbx
movq 0x68(%rax), %rsi
movl 0x54(%rax), %edx
cmpl $0x0, (%rsi,%rdx,4)
je 0x74e2
movq 0x60(%rax), %rsi
movslq (%rsi,%rdx,4), %rdx
testq %rdx, %rdx
js 0x74e2
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rdi
callq 0x6145
testq %rax, %rax
je 0x74d4
movq %rax, %rbx
cmpw $0x0, 0x104(%rax)
je 0x74bd
movq %rbx, %rdi
callq 0x70f4
movq %rbx, %rdi
callq 0x72e5
movq 0x128(%rbx), %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3220
jmp 0x74f4
retq
movq 0x7d65(%rip), %rax      # 0xf240
movq 0x648(%rax), %rax
movq 0x70(%rax), %rax
movq 0x50(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x74f4
callq 0x58dc
popq %rbx
jmp 0x7401
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./menu.c
// Function: menu_sort
int menu_sort(const void *a, const void *b)
{
	const MenuMap *ma = a;
	const MenuMap *mb = b;
	char as[strlen(ma->name)+1];
	char bs[strlen(mb->name)+1];
	for (int i = 0; ma->name[i]; i++) as[i] = tolower(ma->name[i]);
	for (int i = 0; mb->name[i]; i++) bs[i] = tolower(mb->name[i]);
	return strcmp(as, bs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rdi), %r12
movq %r12, %rdi
callq 0x3250
movq %rsp, %rbx
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3250
movq %rsp, %r15
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movb (%r12), %r13b
testb %r13b, %r13b
je 0x756f
callq 0x34e0
movq (%rax), %rax
xorl %ecx, %ecx
movsbq %r13b, %rdx
movb (%rax,%rdx,4), %dl
movb %dl, (%rbx,%rcx)
movb 0x1(%r12,%rcx), %r13b
incq %rcx
testb %r13b, %r13b
jne 0x7558
movb (%r14), %r12b
testb %r12b, %r12b
je 0x7599
callq 0x34e0
movq (%rax), %rax
xorl %ecx, %ecx
movsbq %r12b, %rdx
movb (%rax,%rdx,4), %dl
movb %dl, (%r15,%rcx)
movb 0x1(%r14,%rcx), %r12b
incq %rcx
testb %r12b, %r12b
jne 0x7581
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3470
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./spot.c
// Function: spot_warp_pointer
void spot_warp_pointer(int spot, int mon)
{
	Window wroot, child;
	int root_x, root_y, win_x, win_y;
	unsigned int mask;

	if (XQueryPointer(display, root, &wroot, &child, &root_x, &root_y, &win_x, &win_y, &mask)
		&& !INTERSECT(monitors[mon].spots[spot].x, monitors[mon].spots[spot].y, monitors[mon].spots[spot].w, monitors[mon].spots[spot].h, root_x, root_y, 1, 1))
	{
		XWarpPointer(display, None, root, 0, 0, 0, 0,
			monitors[mon].spots[spot].x + monitors[mon].spots[spot].w - 10,
			monitors[mon].spots[spot].y + 10);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x7097(%rip), %rdi      # 0xebb0
movq 0x7688(%rip), %rsi      # 0xf1a8
subq $0x8, %rsp
leaq 0x14(%rsp), %rax
leaq 0x18(%rsp), %r10
leaq 0x1c(%rsp), %r11
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
pushq %rax
pushq %r10
pushq %r11
callq 0x3580
addq $0x20, %rsp
testl %eax, %eax
je 0x7c33
movslq %ebp, %rax
movslq %ebx, %rcx
leaq (%rax,%rax,8), %rax
leaq 0x7052(%rip), %rdx      # 0xebc0
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,8), %rcx
addq $0x8, %rcx
movswl (%rcx), %eax
movl 0x8(%rsp), %edi
cmpl %eax, %edi
sete %sil
movzwl 0x4(%rcx), %r8d
cmpw $0x1, %r8w
sete %r9b
movw $0x1, %dx
testb %r9b, %sil
jne 0x7bbc
movswl %r8w, %esi
leal (%rsi,%rax), %edx
leal 0x1(%rdi), %r9d
cmpl %edi, %edx
cmovlel %edx, %r9d
cmpl %eax, %edi
cmovlel %eax, %edi
movl %r8d, %edx
cmpl %edi, %r9d
jle 0x7bfb
movswl 0x2(%rcx), %r10d
movl 0x4(%rsp), %esi
cmpl %r10d, %esi
sete %dil
movzwl 0x6(%rcx), %ecx
cmpw $0x1, %cx
sete %r8b
testb %r8b, %dil
jne 0x7c33
movswl %cx, %ecx
addl %r10d, %ecx
leal 0x1(%rsi), %edi
cmpl %esi, %ecx
cmovlel %ecx, %edi
cmpl %r10d, %esi
cmovlel %r10d, %esi
cmpl %esi, %edi
jg 0x7c33
movswl %dx, %esi
jmp 0x7c00
movswl 0x2(%rcx), %r10d
movq 0x6fa9(%rip), %rdi      # 0xebb0
movq 0x759a(%rip), %rdx      # 0xf1a8
addl %esi, %eax
addl $-0xa, %eax
addl $0xa, %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x3450
addq $0x20, %rsp
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seanpringle[P]xoat/./spot.c
// Function: spot_focus_top_window
Window spot_focus_top_window(int spot, int mon, Window except)
{
	int i; Client *c;
	for_windows(i, c) if (c->window != except && c->manage && c->spot == spot && c->monitor == mon)
	{
		client_raise_family(c);
		client_set_focus(c);
		return c->window;
	}
	return None;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
callq 0x604f
movswq 0x714d(%rip), %rcx      # 0xeda0
testq %rcx, %rcx
jle 0x7ca0
movslq %r14d, %rdx
xorl %eax, %eax
leaq 0x713c(%rip), %rsi      # 0xeda0
xorl %edi, %edi
movq 0x8(%rsi,%rdi,8), %r14
testq %r14, %r14
je 0x7c96
cmpq %rbx, (%r14)
je 0x7c96
cmpw $0x0, 0x104(%r14)
je 0x7c96
cmpq %rdx, 0x118(%r14)
jne 0x7c96
movswl 0x100(%r14), %r8d
cmpl %ebp, %r8d
je 0x7ca7
incq %rdi
cmpq %rdi, %rcx
jne 0x7c66
jmp 0x7ca2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x70f4
movq %r14, %rdi
callq 0x72e5
movq (%r14), %rax
jmp 0x7ca2