LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./regex.c
// Function: regex
regex_t*
regex(const char *pattern)
{
	int i = 0;
	unsigned int hash = 0;
	regex_t *re = NULL;
	RegexCache *rc = NULL;

	while (pattern[i])
	{
		hash = 33 * hash + pattern[i++];
	}

	// have we compiled this regex before?
	for (i = 0; i < REGEX_CACHE; i++)
	{
		rc = &regex_cache[i];
		if (rc->hash == hash && rc->pattern && !strcmp(pattern, rc->pattern))
		{
			re = &rc->regex;
			rc->used++;
			break;
		}
	}
	if (!re)
	{
		int slot = 0;
		// look for a free cache slot
		for (i = 0; i < REGEX_CACHE; i++)
		{
			if (!regex_cache[i].pattern)
			{
				slot = i;
				break;
			}
		}
		if (regex_cache[slot].pattern)
		{
			// choose the least used
			for (i = 0; i < REGEX_CACHE; i++)
			{
				if (regex_cache[i].used < regex_cache[slot].used)
				{
					slot = i;
					break;
				}
			}
		}

		rc = &regex_cache[slot];

		if (rc->pattern)
		{
			regfree(&rc->regex);
			free(rc->pattern);
		}

		rc->used = 0;
		rc->hash = 0;
		rc->pattern = NULL;

		re = &rc->regex;

		if (regcomp(re, pattern, REG_EXTENDED) != 0)
		{
			fprintf(stderr, "regex compile failure: %s", pattern);
			re = NULL;
		}
		if (re)
		{
			rc->pattern = strdup(pattern);
			rc->hash = hash;
			rc->used = 1;
		}
	}
	return re;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %rax
movsbl (%rax), %ecx
testl %ecx, %ecx
je 0x37ec
imull $0x21, %ebp, %ebp
addl %ecx, %ebp
incq %rax
jmp 0x37db
xorl %r15d, %r15d
leaq 0xb0ba(%rip), %r14      # 0xe8b0
cmpq $0x2c0, %r15            # imm = 0x2C0
je 0x3825
cmpl %ebp, (%r15,%r14)
jne 0x381f
movq 0x8(%r15,%r14), %rsi
testq %rsi, %rsi
je 0x381f
movq %rbx, %rdi
callq 0x3470
testl %eax, %eax
je 0x38da
addq $0x58, %r15
jmp 0x37f6
leaq 0xb08c(%rip), %rcx      # 0xe8b8
xorl %eax, %eax
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x3847
cmpq $0x0, (%rcx)
je 0x3845
incq %rdx
addq $0x58, %rcx
jmp 0x3830
movl %edx, %eax
movl %eax, %ecx
imulq $0x58, %rcx, %rcx
cmpq $0x0, 0x8(%rcx,%r14)
je 0x3879
addq %r14, %rcx
movl 0x50(%rcx), %edx
leaq 0xb09e(%rip), %rsi      # 0xe900
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x3879
cmpl %edx, (%rsi)
jb 0x3877
incq %rcx
addq $0x58, %rsi
jmp 0x3864
movl %ecx, %eax
cltq
imulq $0x58, %rax, %rax
leaq (%r14,%rax), %r15
cmpq $0x0, 0x8(%rax,%r14)
je 0x389d
leaq 0x10(%r15), %rdi
callq 0x34d0
movq 0x8(%r15), %rdi
callq 0x3220
andl $0x0, 0x50(%r15)
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
leaq 0x10(%r15), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3360
testl %eax, %eax
jne 0x38f3
movq %rbx, %rdi
callq 0x3430
movq %rax, 0x8(%r15)
movl %ebp, (%r15)
movl $0x1, 0x50(%r15)
jmp 0x38e5
addq %r15, %r14
addq $0x10, %r14
incl 0x40(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa6ee(%rip), %rax      # 0xdfe8
movq (%rax), %rdi
leaq 0x6814(%rip), %rsi      # 0xa118
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3660
jmp 0x38e5
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./regex.c
// Function: regex_cache_empty
void
regex_cache_empty()
{
	for (int i = 0; i < REGEX_CACHE; i++)
	{
		RegexCache *rc = &regex_cache[i];
		if (rc->pattern)
		{
			regfree(&rc->regex);
			free(rc->pattern);
			rc->used = 0;
			rc->hash = 0;
			rc->pattern = NULL;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0xaf7b(%rip), %r15      # 0xe8b0
cmpq $0x2c0, %r14            # imm = 0x2C0
je 0x3972
cmpq $0x0, 0x8(%r14,%r15)
je 0x396c
leaq (%r14,%r15), %rbx
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x34d0
movq -0x8(%rbx), %rdi
callq 0x3220
andl $0x0, 0x40(%rbx)
andl $0x0, -0x10(%rbx)
andq $0x0, -0x8(%rbx)
addq $0x58, %r14
jmp 0x3935
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./regex.c
// Function: regex_match
int
regex_match(const char *pattern, const char *subject)
{
	int r = 0; regmatch_t pmatch[REGEX_GROUPS];
	regex_t *re = regex(pattern);
	if (re && subject && (r = regexec(re, subject, REGEX_GROUPS, pmatch, 0) == 0))
	{
		for (int i = 0; i < REGEX_GROUPS && pmatch[i].rm_so != (size_t)-1; i++)
		{
			free(regex_matches[i]);
			int len = pmatch[i].rm_eo - pmatch[i].rm_so;
			regex_matches[i] = malloc(len + 1);
			strncpy(regex_matches[i], subject + pmatch[i].rm_so, len);
			regex_matches[i][len] = 0;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0x37cc
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0x3a17
pushq $0x8
popq %rdx
movq %rsp, %rcx
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x3180
testl %eax, %eax
jne 0x3a17
xorl %r13d, %r13d
leaq 0xb1ac(%rip), %rbp      # 0xeb70
cmpq $0x40, %r13
je 0x3a14
cmpl $-0x1, (%rsp,%r13)
je 0x3a14
movq (%r13,%rbp), %rdi
callq 0x3220
movslq 0x4(%rsp,%r13), %r14
movslq (%rsp,%r13), %r15
subq %r15, %r14
leaq 0x1(%r14), %rdi
callq 0x3150
movq %rax, %r12
movq %rax, (%r13,%rbp)
addq %rbx, %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3570
movb $0x0, (%r12,%r14)
addq $0x8, %r13
jmp 0x39c4
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./textbox.c
// Function: textbox_font
void textbox_font(Textbox *tb, char *font, char *fg, char *bg)
{
	if (tb->font) XftFontClose(display, tb->font);
	tb->font = XftFontOpenName(display, DefaultScreen(display), font);

	XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), fg, &tb->color_fg);
	XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), bg, &tb->color_bg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x3bef
movq 0xafc6(%rip), %rdi      # 0xebb0
callq 0x30a0
movq 0xafba(%rip), %rdi      # 0xebb0
movl 0xe0(%rdi), %esi
movq %r12, %rdx
callq 0x3460
movq %rax, 0x28(%r14)
movq 0xafa1(%rip), %rdi      # 0xebb0
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rsi
movq 0x50(%rax,%rcx), %rdx
leaq 0x30(%r14), %r8
movq %r15, %rcx
callq 0x3390
movq 0xaf72(%rip), %rdi      # 0xebb0
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rsi
movq 0x50(%rax,%rcx), %rdx
addq $0x40, %r14
movq %rbx, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3390
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./textbox.c
// Function: textbox_text
void textbox_text(Textbox *tb, char *text)
{
	if (tb->text) free(tb->text);
	tb->text = strdup(text ? text: "");
	tb->cursor = MAX(0, MIN(strlen(tb->text), tb->cursor));
	textbox_extents(tb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rdi
callq 0x3220
testq %rbx, %rbx
leaq 0x6a79(%rip), %rdi      # 0xa70a
cmovneq %rbx, %rdi
callq 0x3430
movq %rax, 0x50(%r14)
movq %rax, %rdi
callq 0x3250
movswq 0x20(%r14), %rcx
cmpq %rcx, %rax
cmovbl %eax, %ecx
movw %cx, 0x20(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d53
// File: /workspace/github_c_makefile_star2_O2/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 0x3cd7
movq 0x28(%rdi), %r9
movl 0x4(%r9), %r8d
addl (%r9), %r8d
testb $0x2, %al
je 0x3cdf
movzwl 0x70(%rdi), %ecx
movswl 0x18(%rdi), %eax
cmpl %esi, %eax
jne 0x3d01
movswl 0x1a(%rdi), %eax
cmpl %edx, %eax
jne 0x3d01
movswl 0x1c(%rdi), %eax
cmpl %eax, %ecx
jne 0x3d01
movswl 0x1e(%rdi), %eax
cmpl %eax, %r8d
jne 0x3d01
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 0xae81(%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_O2/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
pushq $0x1
popq %rsi
callq 0x3500
movq %rax, %r15
leaq 0x6613(%rip), %rsi      # 0xa3aa
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x32d0
movq 0xae02(%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_O2/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 0x3e43
movq 0x68(%rbx), %rdi
callq 0x3400
movq 0x60(%rbx), %rdi
callq 0x3680
movq 0x50(%rbx), %rdi
callq 0x3220
movq 0x58(%rbx), %rdi
callq 0x3220
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x3e6a
movq 0xad4b(%rip), %rdi      # 0xebb0
callq 0x30a0
movq 0xad3f(%rip), %rdi      # 0xebb0
movq 0x8(%rbx), %rsi
callq 0x3280
movq %rbx, %rdi
popq %rbx
jmp 0x3220
// File: /workspace/github_c_makefile_star2_O2/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 0x43cd
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
leaq 0x10(%rsp), %rdx
pushq $0x20
popq %rcx
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r9
movq %r14, %r8
callq 0x34f0
cltq
movb $0x0, 0x10(%rsp,%rax)
movq (%r14), %rax
leaq -0xff50(%rax), %rcx
cmpq $0x7, %rcx
ja 0x4350
leaq 0x5cc4(%rip), %rax      # 0xa004
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
andw $0x0, 0x20(%rbx)
jmp 0x43c3
cmpq $0xff08, %rax           # imm = 0xFF08
je 0x43bb
cmpq $0xff0d, %rax           # imm = 0xFF0D
je 0x43b7
cmpq $0xffff, %rax           # imm = 0xFFFF
jne 0x4372
movq %rbx, %rdi
callq 0x42c8
jmp 0x43c3
callq 0x3290
movq (%rax), %rcx
movsbq 0x10(%rsp), %rdx
xorl %eax, %eax
testb $0x2, (%rcx,%rdx,2)
jne 0x43c6
movswl 0x20(%rbx), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x41bc
movq %rbx, %rdi
callq 0x418d
jmp 0x43c3
movq %rbx, %rdi
callq 0x41a9
jmp 0x43c3
movq %rbx, %rdi
callq 0x4198
jmp 0x43c3
pushq $-0x1
jmp 0x43c5
movq %rbx, %rdi
callq 0x42d4
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x45ab
movl %r8d, %r9d
jmp 0x45c0
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 0x45fd
pushq %rbx
movl 0x50(%rdi), %r10d
xorl %r11d, %r11d
movl %ecx, %r8d
cmpq %r11, %r10
je 0x45f3
movq 0x58(%rdi), %rbx
movq (%rbx,%r11,8), %rbx
movzwl 0x70(%rbx), %ebx
movswl %r8w, %r8d
cmpl %r8d, %ebx
cmovgl %ebx, %r8d
incq %r11
jmp 0x45d2
movzwl 0x22(%rdi), %r10d
leal (%r8,%r10,2), %r8d
popq %rbx
cmpw %r8w, %cx
movl %r8d, %r10d
cmovgl %ecx, %r10d
testb $0x8, %al
cmovel %r8d, %r10d
cmpw %si, 0x18(%rdi)
jne 0x4629
cmpw %dx, 0x1a(%rdi)
jne 0x4629
cmpw 0x1c(%rdi), %r10w
jne 0x4629
cmpw 0x1e(%rdi), %r9w
jne 0x4629
retq
movw %si, 0x18(%rdi)
movw %dx, 0x1a(%rdi)
cmpw $0x2, %r10w
movl $0x1, %eax
movl %eax, %r8d
cmovgel %r10d, %r8d
movw %r8w, 0x1c(%rdi)
cmpw $0x2, %r9w
cmovll %eax, %r9d
movw %r9w, 0x1e(%rdi)
movq 0xa554(%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_O2/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
subq $0x30, %rsp
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
imulw 0x20(%rbx), %r12w
movswl 0x22(%rbx), %edx
addl %edx, %r12d
movl 0x1c(%rbx), %eax
subl %edx, %eax
subl %edx, %eax
movq 0x28(%rbx), %rcx
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %r8
movq %r14, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rcx, (%rsp)
andq $0x0, 0x20(%rsp)
movswl %r12w, %ecx
movswl %ax, %r8d
pushq $0x3
popq %rsi
xorl %r9d, %r9d
callq 0x3a28
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 0x4772
movswl 0x18(%rbx), %esi
movswl 0x1a(%rbx), %edx
movswl 0x1c(%rbx), %ecx
movswl 0x1e(%rbx), %r8d
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x459f
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seanpringle[P]xoat/./menubox.c
// Function: menubox_grab
void menubox_grab(Menubox *mb)
{
	for (uint i = 0; i < 1000; i++)
	{
		if (XGrabKeyboard(display, mb->window, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess)
			break;
		usleep(1000);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x3e8, %r14d           # imm = 0x3E8
pushq $0x1
popq %rbp
subl $0x1, %r14d
jb 0x47d8
movq 0xa3fb(%rip), %rdi      # 0xebb0
movq 0x8(%rbx), %rsi
movl %ebp, %edx
movl %ebp, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3550
testl %eax, %eax
je 0x47d8
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x3320
jmp 0x47a8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e83
movq 0x70(%rbx), %rax
movq 0x50(%rax), %rax
movb (%rax), %bpl
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x50(%rbx), %eax
cmpq %rax, %r14
jae 0x48a0
testb %bpl, %bpl
je 0x481d
movq 0x68(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
je 0x488b
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 0x3bc6
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 0x3cc5
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3e01
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3e83
jmp 0x4898
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3e14
incq %r14
jmp 0x4801
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movl 0x50(%rbx), %eax
movq 0x58(%rbx), %rdi
cmpq %rax, %r14
jae 0x4900
movq (%rdi,%r14,8), %rdi
callq 0x3e27
incq %r14
jmp 0x48e6
callq 0x3220
movq 0x60(%rbx), %rdi
callq 0x3220
movq 0x68(%rbx), %rdi
callq 0x3220
movq 0x70(%rbx), %rdi
callq 0x3e27
movq 0xa289(%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_O2/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, (%rsp)
movq %rax, %r15
movsbq (%r15), %r12
testq %r12, %r12
je 0x4981
callq 0x34e0
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, (%r15)
incq %r15
jmp 0x4964
xorl %r12d, %r12d
movl 0x50(%rbx), %r15d
cmpq %r15, %r12
jae 0x49ea
movq 0x58(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x50(%rax), %rdi
callq 0x3430
movq %rax, %r13
movq %rax, %r15
movsbq (%r15), %r14
testq %r14, %r14
je 0x49c1
callq 0x34e0
movq (%rax), %rax
movb (%rax,%r14,4), %al
movb %al, (%r15)
incq %r15
jmp 0x49a4
pushq $0x1
popq %rax
testb %bpl, %bpl
je 0x49d5
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x3978
movq 0x68(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
movq %r13, %rdi
callq 0x3220
incq %r12
jmp 0x4984
movq (%rsp), %rdi
callq 0x3220
movq 0x68(%rbx), %rax
movl 0x54(%rbx), %esi
movl %esi, %ecx
movl (%rax,%rcx,4), %edx
subl $0x1, %esi
jb 0x4a0d
testl %edx, %edx
jne 0x4a0d
movl %esi, 0x54(%rbx)
jmp 0x49fa
decl %r15d
leal 0x1(%rcx), %esi
cmpq %r15, %rcx
jae 0x4a2a
testl %edx, %edx
jne 0x4a2a
movl %esi, 0x54(%rbx)
movl 0x4(%rax,%rcx,4), %edx
incq %rcx
incl %esi
jmp 0x4a13
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rcx
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r9
movq %r15, %r8
callq 0x34f0
cltq
movb $0x0, 0x10(%rsp,%rax)
movq (%r15), %rax
cmpq $0xff0d, %rax           # imm = 0xFF0D
je 0x4adc
cmpq $0xff1b, %rax           # imm = 0xFF1B
je 0x4ac2
cmpq $0xff54, %rax           # imm = 0xFF54
je 0x4ac6
cmpq $0xff52, %rax           # imm = 0xFF52
jne 0x4ae1
movl 0x54(%rbx), %eax
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x4aef
decl %eax
jmp 0x4ad7
pushq $-0x2
jmp 0x4ade
movl 0x50(%rbx), %ecx
movl 0x54(%rbx), %eax
decl %ecx
pushq $0x1
popq %rbp
cmpl %ecx, %eax
jae 0x4aef
incl %eax
movl %eax, 0x54(%rbx)
jmp 0x4aef
pushq $-0x1
popq %rbp
jmp 0x4aef
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x42ee
movl %eax, %ebp
movq %rbx, %rdi
callq 0x493f
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b9a
movl %esi, %edx
movl 0x118(%rbx), %edi
movswl 0x100(%rbx), %ebp
movl %ebp, %esi
callq 0x70ae
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x60e9
movq %rbx, %rdi
callq 0x6580
movq 0x118(%rbx), %rdi
movw %di, 0xa6c7(%rip)       # 0xf248
movswl 0x100(%rbx), %esi
movw %si, 0xa6bb(%rip)       # 0xf24a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6eb3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c13
movq %rdx, %rbx
movl %esi, %ebp
callq 0x5607
movl 0xa1e7(%rip), %ecx      # 0xeda0
xorl %eax, %eax
testw %cx, %cx
cmovlel %eax, %ecx
movzwl %cx, %ecx
leaq 0xa1d5(%rip), %rdx      # 0xeda0
xorl %esi, %esi
cmpq %rax, %rcx
je 0x4c13
movq 0x8(%rdx,%rax,8), %rdi
testq %rdi, %rdi
je 0x4c0e
cmpw $0x0, 0x104(%rdi)
je 0x4c0e
movq 0x118(%rdi), %r8
cmpq 0x118(%rbx), %r8
jne 0x4c0e
movzwl 0x100(%rdi), %r8d
cmpw 0x100(%rbx), %r8w
jne 0x4c0e
cmpl %ebp, %esi
je 0x4c1a
incl %esi
incq %rax
jmp 0x4bcd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6809
// File: /workspace/github_c_makefile_star2_O2/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 0x4ca7
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 0x7197
cmpl $0x2, %eax
jl 0x4c9d
movswq (%rsp), %rax
movl %eax, %eax
testl %eax, %eax
jle 0x4c9d
movq (%rsp,%rax,8), %rdi
testq %rdi, %rdi
je 0x4c93
cmpw $0x0, 0x104(%rdi)
je 0x4c93
cmpq $0x0, 0x90(%rdi)
jne 0x4c93
movq (%rdi), %rcx
cmpq (%rbx), %rcx
jne 0x4c98
decq %rax
jmp 0x4c6a
callq 0x6809
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4dc0
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpw $0x0, 0x10a(%rdx)
je 0x4d49
movq (%rbx), %rdi
movq 0x9f93(%rip), %rsi      # 0xeca0
leaq 0xa49c(%rip), %rdx      # 0xf1b0
leaq 0xa49d(%rip), %rcx      # 0xf1b8
movq %rsp, %r8
pushq $0x8
popq %r9
callq 0x5324
testl %eax, %eax
je 0x4d49
cmpq $0x6, 0xa47d(%rip)      # 0xf1b0
jne 0x4d49
cmpl $0x0, 0xa47c(%rip)      # 0xf1b8
je 0x4d49
movq (%rsp), %rax
movq %rax, 0x118(%rbx)
movq 0x9e60(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq 0x9f46(%rip), %rdx      # 0xeca0
leaq 0x118(%rbx), %r14
pushq $0x6
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x35d0
popq %rcx
popq %rdx
movq 0x9fcb(%rip), %rsi      # 0xed48
movq %rbx, %rdi
callq 0x5edb
cmpw $0x0, 0x10a(%rbx)
je 0x4d94
pushq $0x1
popq %rsi
jmp 0x4d97
movl (%r14), %esi
movswl 0x100(%rbx), %edx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x60e9
movq %rbx, %rdi
callq 0x5f9b
movq %rbx, %rdi
callq 0x6580
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e95
pushq %rbx
movq %rdx, %rbx
leaq 0x120(%rdx), %rax
xorl %ecx, %ecx
cmpq $0x0, 0x120(%rdx)
sete %cl
movq %rcx, 0x120(%rdx)
movq 0x9d52(%rip), %rdi      # 0xebb0
movq (%rdx), %rsi
movq 0x9e50(%rip), %rdx      # 0xecb8
pushq $0x6
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x35d0
popq %rcx
popq %rdx
movl 0x118(%rbx), %esi
movswl 0x100(%rbx), %edx
pushq $0x1
popq %rcx
movq %rbx, %rdi
popq %rbx
jmp 0x60e9
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x2a(%rip), %rsi       # 0x4ed4
pushq $0x11
popq %rdi
callq 0x3380
testq %rbx, %rbx
je 0x4f19
cmpb $0x0, (%rbx)
je 0x4f19
callq 0x3610
testl %eax, %eax
je 0x4f1b
popq %rbx
retq
callq 0x3090
leaq 0x5495(%rip), %rdi      # 0xa3bc
leaq 0x5493(%rip), %rsi      # 0xa3c1
leaq 0x548f(%rip), %rdx      # 0xa3c4
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3190
pushq $0x1
popq %rdi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%r14)
movq 0x9848(%rip), %rdi      # 0xebb0
pushq $0x4
popq %rcx
movl %r15d, %eax
cltd
idivl %ecx
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 $0x0
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 0x541e
cmpq $0x0, (%r13)
setne %cl
movl 0xc(%rsp), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x541e
movq 0x20(%rsp), %rbx
movq %rbx, %rcx
cmpl $0x8, %eax
je 0x53f4
cmpl $0x20, %eax
je 0x53ec
cmpl $0x10, %eax
jne 0x540b
leaq (%rbx,%rbx), %rcx
jmp 0x53f4
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
pushq $0x1
popq %r12
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_O2/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
andq $0x0, 0x8(%rsp)
movq 0x9764(%rip), %rdi      # 0xebb0
leaq 0x10(%rsp), %rdx
callq 0x3270
xorl %ebx, %ebx
testl %eax, %eax
je 0x5503
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x5503
cmpq $0x0, 0x28(%rsp)
je 0x5503
cmpq $0x1f, 0x18(%rsp)
jne 0x54a3
movq %r14, %rdi
callq 0x3250
leaq 0x1(%rax), %rdi
callq 0x3150
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3480
jmp 0x5503
movq 0x9706(%rip), %rdi      # 0xebb0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x31c0
xorl %ebx, %ebx
testl %eax, %eax
js 0x5503
cmpl $0x0, 0x4(%rsp)
jle 0x5503
movq 0x8(%rsp), %r14
movq (%r14), %r15
testq %r15, %r15
je 0x5501
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 0x5503
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5512
callq 0x3050
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
movq 0x97be(%rip), %rsi      # 0xecf0
callq 0x5430
movq %rax, %rbx
testq %rax, %rax
jne 0x5577
movq 0x966a(%rip), %rdi      # 0xebb0
movq %rsp, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3510
movq (%rbx), %r14
testl %eax, %eax
je 0x5568
movq %r14, %rdi
callq 0x3430
movq %rax, %rbx
jmp 0x556a
xorl %ebx, %ebx
testq %r14, %r14
je 0x5577
movq %r14, %rdi
callq 0x3050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x97eb(%rip), %rcx      # 0xed98
movq %rcx, 0x40(%r8)
movl $0x1, 0x10(%r8)
movl $0x20, 0x30(%r8)
movq 0x95e8(%rip), %rdi      # 0xebb0
movq %rax, %rsi
xorl %edx, %edx
movq %r9, %rcx
callq 0x3440
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movq 0x95cd(%rip), %rdi      # 0xebb0
callq 0x3410
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x9791(%rip)      # 0xeda0
je 0x5612
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x958e(%rip), %rdi      # 0xebb0
movq 0x9b7f(%rip), %rsi      # 0xf1a8
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
leaq 0xc(%rsp), %r9
callq 0x36a0
testl %eax, %eax
je 0x56cc
cmpq $0x0, (%rsp)
je 0x56cc
movl 0xc(%rsp), %ebx
decq %rbx
leaq 0x9743(%rip), %r14      # 0xeda0
movq (%rsp), %rdi
testl %ebx, %ebx
js 0x56c7
cmpw $0x3f, 0x9733(%rip)     # 0xeda0
jg 0x56c7
movl %ebx, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq (%rdi,%r15,8), %rdi
callq 0x56d6
testq %rax, %rax
je 0x56ba
cmpw $0x0, 0x102(%rax)
je 0x56ba
movswq 0x9707(%rip), %rcx      # 0xeda0
movq %rax, 0x8(%r14,%rcx,8)
movq (%rsp), %rax
movq (%rax,%r15,8), %rax
leal 0x1(%rcx), %edx
movw %dx, 0x96f0(%rip)       # 0xeda0
movq %rax, 0x208(%r14,%rcx,8)
jmp 0x56c2
movq %rax, %rdi
callq 0x5dae
decq %rbx
jmp 0x565d
callq 0x3050
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
leaq 0x8(%rsp), %rdi
xorl %ebx, %ebx
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
callq 0x5607
movswq 0x8fa8(%rip), %rax      # 0xeda0
leaq 0x210(%rsp), %r14
movl %eax, %eax
leaq 0x8f97(%rip), %rcx      # 0xeda0
movl %eax, %edx
leaq (%rcx,%rax,8), %rsi
decq %rax
testl %edx, %edx
jle 0x5e49
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5e28
cmpw $0x0, 0x104(%rdi)
jne 0x5e33
decl %edx
decq %rax
addq $-0x8, %rsi
jmp 0x5e12
movq (%rdi), %rdx
movswq %bx, %rsi
leal 0x1(%rbx), %edi
movq %rdx, 0x210(%rsp,%rsi,8)
movl %edi, %ebx
jmp 0x5e09
movw %bx, 0x8(%rsp)
movq 0x8d5b(%rip), %rdi      # 0xebb0
movq 0x934c(%rip), %rsi      # 0xf1a8
movq 0x8e75(%rip), %rdx      # 0xecd8
movswl %bx, %eax
pushq $0x21
popq %rbx
pushq $0x20
popq %rbp
movq %rbx, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r14
callq 0x35d0
popq %rcx
popq %rdx
movq 0x8d2a(%rip), %rdi      # 0xebb0
movq 0x931b(%rip), %rsi      # 0xf1a8
movq 0x8e4c(%rip), %rdx      # 0xece0
movswl 0x8(%rsp), %eax
movq %rbx, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r14
callq 0x35d0
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x9, %ecx
jg 0x5f2a
movslq %ecx, %rdx
movq (%rax,%rdx,8), %rdx
testq %rdx, %rdx
je 0x5f2a
xorl %esi, %esi
cmpq %r14, %rdx
sete %sil
leal (%rcx,%rsi), %edx
movslq %edx, %rdx
movq 0xa8(%rbx,%rdx,8), %rdx
movq %rdx, 0xa8(%rbx,%r10,8)
addl %esi, %ecx
incl %ecx
incq %r10
jmp 0x5ef1
cmpl %ecx, %r10d
sete %dl
cmpq $0xa, %r10
setb %sil
testb %sil, %dl
je 0x5f4d
movl %ecx, %edx
incl %ecx
movq %r14, (%rax,%rdx,8)
pushq $0x1
popq %rbp
movl %ecx, %r10d
jmp 0x5f4f
xorl %ebp, %ebp
movq 0x8c5a(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq 0x8de0(%rip), %rdx      # 0xed40
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x35d0
popq %rcx
popq %rdx
cmpq %r14, 0x8dcd(%rip)      # 0xed48
jne 0x5f84
movw %bp, 0x10a(%rbx)
cmpq %r14, 0x8dd5(%rip)      # 0xed60
jne 0x5f94
movw %bp, 0x108(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8c00(%rip), %r14      # 0xebb0
movq 0xe8(%r14), %rax
movslq 0xe0(%r14), %rcx
shlq $0x7, %rcx
movq 0x50(%rax,%rcx), %rsi
movq (%rdi), %r15
cmpq 0x8be7(%rip), %r15      # 0xebb8
jne 0x5fdc
movq 0x91f6(%rip), %rdx      # 0xf1d0
jmp 0x5ff8
xorl %eax, %eax
cmpw $0x0, 0x108(%rbx)
setne %al
leaq 0x91d0(%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 0x6016
movq 0x8(%rsp), %rdx
jmp 0x6018
xorl %edx, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3260
movq 0x8b86(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
cmpw $0x0, 0x10a(%rbx)
jne 0x603e
movl 0x9182(%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_O2/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 0x5607
xorl %r12d, %r12d
movzwl 0x88ad(%rip), %eax      # 0xeda0
leaq 0x88a6(%rip), %r13      # 0xeda0
xorl %r15d, %r15d
movswq %ax, %rcx
cmpq %rcx, %r12
jge 0x6557
movq 0x8(%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x6552
cmpw $0x0, 0x104(%rdi)
movzwl 0x102(%rdi), %ecx
je 0x6543
testw %cx, %cx
je 0x6552
movq 0x90(%rdi), %rcx
cmpq (%r14), %rcx
jne 0x6548
movq %rbx, %rsi
callq 0x64d5
movzwl 0x885f(%rip), %eax      # 0xeda0
jmp 0x6552
testw %cx, %cx
je 0x6552
movq (%rdi), %rcx
cmpq (%r14), %rcx
cmoveq %rdi, %r15
incq %r12
jmp 0x64fd
testq %r15, %r15
je 0x6576
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_O2/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 0x672c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rdi, %rbx
movq %rsp, %r14
xorl %r12d, %r12d
movl $0x408, %edx            # imm = 0x408
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
leaq 0x408(%rsp), %rdi
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
callq 0x5607
leaq 0x87cf(%rip), %r13      # 0xeda0
movswq 0x87c7(%rip), %rax      # 0xeda0
cmpq %rax, %r12
jge 0x6632
movq 0x8(%r13,%r12,8), %r15
testq %r15, %r15
je 0x662d
movq 0xa0(%r15), %rax
cmpq 0x872a(%rip), %rax      # 0xed20
jne 0x6603
movq %r15, %rdi
movq %r14, %rsi
callq 0x64d5
cmpw $0x0, 0x116(%r15)
je 0x662d
cmpq $0x3, 0x118(%rbx)
je 0x662d
cmpq $0x3, 0x118(%r15)
jne 0x662d
movq %r15, %rdi
movq %r14, %rsi
callq 0x64d5
incq %r12
jmp 0x65d1
movw $0xffff, %r15w          # imm = 0xFFFF
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x666f
callq 0x56d6
testq %rax, %rax
je 0x666f
cmpw $0x0, 0x104(%rax)
je 0x666f
leal 0x1(%r15), %ecx
movswq %cx, %rcx
movq %rax, 0x410(%rsp,%rcx,8)
incl %r15d
movq %rax, %rbx
jmp 0x6637
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64d5
cmpw $0x0, 0x10a(%rbx)
movzwl (%r14), %r14d
jne 0x66d5
cmpq $0x0, 0x8b55(%rip)      # 0xf1e8
je 0x66d5
movswq %r14w, %r14
movswq 0x100(%rbx), %rax
movq 0x118(%rbx), %rcx
imulq $0x48, %rax, %rax
leaq 0x850d(%rip), %rdx      # 0xebc0
addq %rax, %rdx
movq 0x28(%rdx,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x208(%rsp,%r14,8)
andq $0x0, 0x8(%rsp,%r14,8)
incl %r14d
movw %r14w, (%rsp)
movq 0x84d4(%rip), %rdi      # 0xebb0
leaq 0x208(%rsp), %rbx
movq (%rbx), %rsi
callq 0x3110
movq 0x84bd(%rip), %rdi      # 0xebb0
movswl %r14w, %edx
movq %rbx, %rsi
callq 0x32e0
cmpw $-0x1, %r15w
je 0x671c
movswq %r15w, %rax
movq 0x410(%rsp,%rax,8), %rdi
callq 0x5dae
decl %r15d
jmp 0x66ff
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6752
movq %rdi, %rbx
cmpw $0x0, 0x102(%rdi)
je 0x6752
movq (%rbx), %rax
movq 0x846b(%rip), %rdi      # 0xebb8
cmpq %rdi, %rax
jne 0x675a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x8457(%rip)      # 0xebb8
movzwl 0x118(%rbx), %eax
movw %ax, 0x8ad9(%rip)       # 0xf248
movzwl 0x100(%rbx), %eax
movw %ax, 0x8acd(%rip)       # 0xf24a
testq %rdi, %rdi
je 0x679f
callq 0x56d6
testq %rax, %rax
je 0x679f
movq %rax, %r14
movq %rax, %rdi
callq 0x5f9b
movq %r14, %rdi
callq 0x5dae
movq 0x85e2(%rip), %rsi      # 0xed88
movq %rbx, %rdi
callq 0x6052
movq 0x83fb(%rip), %rdi      # 0xebb0
cmpw $0x0, 0x106(%rbx)
je 0x67c4
movq (%rbx), %rsi
jmp 0x67c7
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x33f0
movq 0x83d8(%rip), %rdi      # 0xebb0
movq 0x89c9(%rip), %rsi      # 0xf1a8
movq 0x84e2(%rip), %rdx      # 0xecc8
pushq $0x21
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %rbx
callq 0x35d0
popq %rcx
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5f9b
// File: /workspace/github_c_makefile_star2_O2/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 0x8a05(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x6889
callq 0x48dc
movq 0x89ed(%rip), %rax      # 0xf240
andq $0x0, 0x648(%rax)
pushq $0x10
popq %rbx
cmpq $0x650, %rbx            # imm = 0x650
je 0x6889
movq 0x89d2(%rip), %rax      # 0xf240
movq (%rax,%rbx), %rdi
callq 0x3220
movq 0x89c2(%rip), %rax      # 0xf240
andq $0x0, (%rax,%rbx)
addq $0x10, %rbx
jmp 0x685e
popq %rbx
retq