LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7279
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
leaq 0x410(%rsp), %rdi
movl $0x408, %edx            # imm = 0x408
xorl %esi, %esi
callq 0x3070
callq 0x606d
cmpw $0x0, 0x7cd0(%rip)      # 0xeda0
jle 0x7140
xorl %r12d, %r12d
leaq 0x7cc4(%rip), %r13      # 0xeda0
leaq 0x8(%rsp), %r14
movq 0x8(%r13,%r12,8), %r15
testq %r15, %r15
je 0x7130
movq 0xa0(%r15), %rax
cmpq 0x7c27(%rip), %rax      # 0xed20
jne 0x7106
movq %r15, %rdi
movq %r14, %rsi
callq 0x6fd0
cmpw $0x0, 0x116(%r15)
je 0x7130
cmpq $0x3, 0x118(%rbx)
je 0x7130
cmpq $0x3, 0x118(%r15)
jne 0x7130
movq %r15, %rdi
movq %r14, %rsi
callq 0x6fd0
incq %r12
movswq 0x7c65(%rip), %rax      # 0xeda0
cmpq %rax, %r12
jl 0x70e1
movzwl 0x410(%rsp), %ebp
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x71a2
callq 0x6148
testq %rax, %rax
je 0x71a2
movl %ebp, %r15d
cmpw $0x0, 0x104(%rax)
je 0x719f
movq %rax, %r14
movswq %r15w, %rax
movq %r14, 0x418(%rsp,%rax,8)
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0x7197
callq 0x6148
leal 0x1(%r15), %ebp
movq %r14, %rbx
testq %rax, %rax
jne 0x715e
incl %r15d
movl %r15d, %ebp
jmp 0x71a5
movl %r15d, %ebp
movq %rbx, %r14
movw %bp, 0x410(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6fd0
cmpw $0x0, 0x10a(%r14)
jne 0x7215
cmpq $0x0, 0x801b(%rip)      # 0xf1e8
je 0x7215
movswq 0x100(%r14), %rax
movq 0x118(%r14), %rcx
leaq (%rax,%rax,8), %rax
leaq 0x79d7(%rip), %rdx      # 0xebc0
leaq (%rdx,%rax,8), %rax
movq 0x28(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movswq 0x8(%rsp), %rcx
movq %rax, 0x210(%rsp,%rcx,8)
movq $0x0, 0x10(%rsp,%rcx,8)
leal 0x1(%rcx), %eax
movw %ax, 0x8(%rsp)
movq 0x7994(%rip), %rdi      # 0xebb0
leaq 0x210(%rsp), %rbx
movq (%rbx), %rsi
callq 0x3110
movq 0x797d(%rip), %rdi      # 0xebb0
movswl -0x208(%rbx), %edx
movq %rbx, %rsi
callq 0x32e0
movzwl 0x410(%rsp), %ebx
testw %bx, %bx
je 0x7268
decl %ebx
movswq %bx, %rbx
movq 0x418(%rsp,%rbx,8), %rdi
callq 0x6884
addw $-0x1, %bx
jb 0x7251
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x729f
movq %rdi, %rbx
cmpw $0x0, 0x102(%rdi)
je 0x729f
movq (%rbx), %rax
movq 0x791e(%rip), %rdi      # 0xebb8
cmpq %rdi, %rax
jne 0x72a7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x790a(%rip)      # 0xebb8
movzwl 0x118(%rbx), %eax
movw %ax, 0x7f8c(%rip)       # 0xf248
movzwl 0x100(%rbx), %eax
movw %ax, 0x7f80(%rip)       # 0xf24a
testq %rdi, %rdi
je 0x72f8
callq 0x6148
testq %rax, %rax
je 0x72f8
movq %rax, %r14
movq %rax, %rdi
callq 0x6a78
movq 0x128(%r14), %rdi
callq 0x3220
movq %r14, %rdi
callq 0x3220
movq 0x7a89(%rip), %rsi      # 0xed88
movq %rbx, %rdi
callq 0x6b2f
movq 0x78a2(%rip), %rdi      # 0xebb0
cmpw $0x0, 0x106(%rbx)
je 0x731d
movq (%rbx), %rsi
jmp 0x7322
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x33f0
movq 0x787b(%rip), %rdi      # 0xebb0
movq 0x7e6c(%rip), %rsi      # 0xf1a8
movq 0x7985(%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 0x6a78
// File: /workspace/github_c_makefile_star2_O1/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 0x7ea2(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x73f2
callq 0x5274
movq 0x7e8a(%rip), %rax      # 0xf240
movq $0x0, 0x648(%rax)
movl $0x10, %ebx
movq 0x7e73(%rip), %rax      # 0xf240
movq (%rax,%rbx), %rdi
callq 0x3220
movq 0x7e63(%rip), %rax      # 0xf240
movq $0x0, (%rax,%rbx)
addq $0x10, %rbx
cmpq $0x650, %rbx            # imm = 0x650
jne 0x73c6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7e45(%rip), %rax      # 0xf240
movq 0x648(%rax), %rcx
testq %rcx, %rcx
je 0x741d
movq 0x68(%rcx), %rsi
movl 0x54(%rcx), %edx
cmpl $0x0, (%rsi,%rdx,4)
je 0x741e
movq 0x60(%rcx), %rcx
movl (%rcx,%rdx,4), %ecx
jmp 0x7423
retq
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
pushq %rbx
testl %ecx, %ecx
js 0x7470
movl %ecx, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdi
callq 0x6148
testq %rax, %rax
je 0x7470
movq %rax, %rbx
cmpw $0x0, 0x104(%rax)
je 0x745a
movq %rbx, %rdi
callq 0x7081
movq %rbx, %rdi
callq 0x727a
movq 0x128(%rbx), %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3220
jmp 0x7490
movq 0x7dc9(%rip), %rax      # 0xf240
movq 0x648(%rax), %rax
movq 0x70(%rax), %rax
movq 0x50(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x7490
callq 0x590f
popq %rbx
jmp 0x7396
// File: /workspace/github_c_makefile_star2_O1/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 0x750b
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 0x74f4
movb (%r14), %r12b
testb %r12b, %r12b
je 0x7535
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 0x751d
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_O1/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 0x70e1(%rip), %rdi      # 0xebb0
movq 0x76d2(%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 0x7bc3
movslq %ebp, %rax
movslq %ebx, %rcx
leaq (%rax,%rax,8), %rax
leaq 0x709c(%rip), %rdx      # 0xebc0
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
movswl (%rax), %ecx
movl 0x8(%rsp), %edx
cmpl %ecx, %edx
jne 0x7b42
cmpw $0x1, 0x4(%rax)
je 0x7b59
movswl 0x4(%rax), %esi
addl %ecx, %esi
leal 0x1(%rdx), %edi
cmpl %edx, %esi
cmovlel %esi, %edi
cmpl %ecx, %edx
cmovlel %ecx, %edx
cmpl %edx, %edi
jle 0x7b86
movswl 0x2(%rax), %edx
movl 0x4(%rsp), %esi
cmpl %edx, %esi
jne 0x7b6c
cmpw $0x1, 0x6(%rax)
je 0x7bc3
movswl 0x6(%rax), %edi
addl %edx, %edi
leal 0x1(%rsi), %r8d
cmpl %esi, %edi
cmovlel %edi, %r8d
cmpl %edx, %esi
cmovgl %esi, %edx
cmpl %edx, %r8d
jg 0x7bc3
movq 0x7023(%rip), %rdi      # 0xebb0
movq 0x7614(%rip), %rdx      # 0xf1a8
movswl 0x4(%rax), %esi
leal (%rcx,%rsi), %r10d
addl $-0xa, %r10d
movswl 0x2(%rax), %eax
addl $0xa, %eax
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq $0x0
callq 0x3450
addq $0x20, %rsp
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x606d
movswq 0x71bd(%rip), %rcx      # 0xeda0
testq %rcx, %rcx
jle 0x7c30
movslq %r14d, %rdx
xorl %eax, %eax
leaq 0x71ac(%rip), %rsi      # 0xeda0
xorl %edi, %edi
movq 0x8(%rsi,%rdi,8), %r14
testq %r14, %r14
je 0x7c26
cmpq %rbx, (%r14)
je 0x7c26
cmpw $0x0, 0x104(%r14)
je 0x7c26
cmpq %rdx, 0x118(%r14)
jne 0x7c26
movswl 0x100(%r14), %r8d
cmpl %ebp, %r8d
je 0x7c37
incq %rdi
cmpq %rdi, %rcx
jne 0x7bf6
jmp 0x7c32
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x7081
movq %r14, %rdi
callq 0x727a
movq (%r14), %rax
jmp 0x7c32
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./spot.c
// Function: spot_try_focus_top_window
Window spot_try_focus_top_window(int spot, int mon, Window except)
{
	Window w = spot_focus_top_window(spot, mon, except);
	if (w == None)
	{
		current      = None;
		current_mon  = mon;
		current_spot = spot;
		update_bars();

		XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime);
	}
	return w;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
callq 0x7bca
movq %rax, %rbx
testq %rax, %rax
jne 0x7c99
movq $0x0, 0x6f4b(%rip) # 0xebb8
movw %r14w, 0x75d5(%rip)     # 0xf24a
movw %bp, 0x75cc(%rip)       # 0xf248
callq 0x7a80
movq 0x6f28(%rip), %rdi      # 0xebb0
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x33f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./spot.c
// Function: spot_choose_by_direction
int spot_choose_by_direction(int spot, int mon, int dir)
{
	Monitor *m = &monitors[mon];
	int spot1_align = have_layout(mon) ? settings.layouts[mon].spot1_align : LEFT ;

	if (m->w < m->h) // rotated?
	{
		if (dir == LEFT)  return SPOT3;
		if (dir == RIGHT) return SPOT2;
		if (dir == UP)    return spot1_align == LEFT ? SPOT1: SPOT2;
		if (dir == DOWN)  return spot1_align == LEFT ? SPOT2: SPOT1;
		return spot;
	}
	if (dir == UP)    return SPOT2;
	if (dir == DOWN)  return SPOT3;
	if (dir == LEFT)  return spot1_align == LEFT ? SPOT1: SPOT2;
	if (dir == RIGHT) return spot1_align == LEFT ? SPOT2: SPOT1;
	return spot;
}

// Assembly:
movl %edi, %eax
movslq %esi, %rdi
leaq (%rdi,%rdi,8), %rcx
leaq 0x6f0f(%rip), %rsi      # 0xebc0
leaq (%rsi,%rcx,8), %rsi
movb $0x1, %cl
cmpl %edi, 0x7553(%rip)      # 0xf210
jbe 0x7ccf
movq 0x7552(%rip), %rcx      # 0xf218
cmpw $0x1, 0x2(%rcx,%rdi,8)
sete %cl
movzwl 0x4(%rsi), %edi
cmpw 0x6(%rsi), %di
jge 0x7cf0
decl %edx
cmpl $0x3, %edx
ja 0x7d17
leaq 0x235d(%rip), %rax      # 0xa044
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
decl %edx
cmpl $0x3, %edx
ja 0x7d17
leaq 0x2336(%rip), %rax      # 0xa034
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzbl %cl, %ecx
movl $0x2, %eax
subl %ecx, %eax
retq
movzbl %cl, %eax
incl %eax
retq
movl $0x2, %eax
retq
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./spot.c
// Function: spot_stack_clients
int spot_stack_clients(int spot, int mon, Stack *stk)
{
	int i; Client *c;
	for_windows(i, c) if (c->manage && c->spot == spot && c->monitor == mon)
		client_stack_family(c, stk);
	return stk->depth;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
callq 0x606d
cmpw $0x0, 0x6ff2(%rip)      # 0xeda0
jle 0x7dfd
movslq %r14d, %r14
xorl %r15d, %r15d
leaq 0x6fe3(%rip), %r12      # 0xeda0
movq 0x8(%r12,%r15,8), %rdi
testq %rdi, %rdi
je 0x7ded
cmpw $0x0, 0x104(%rdi)
je 0x7ded
cmpq %r14, 0x118(%rdi)
jne 0x7ded
movswl 0x100(%rdi), %eax
cmpl %ebp, %eax
jne 0x7ded
movq %rbx, %rsi
callq 0x6fd0
incq %r15
movswq 0x6fa8(%rip), %rax      # 0xeda0
cmpq %rax, %r15
jl 0x7dbd
movswl (%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: create_notify
void create_notify(XEvent *e)
{
	Client *c = window_build_client(e->xcreatewindow.window);
	if (c && c->manage)
		window_listen(c->window);
	client_free(c);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x7e39
cmpw $0x0, 0x104(%rbx)
je 0x7e39
movq (%rbx), %rsi
movq 0x6d81(%rip), %rdi      # 0xebb0
movl $0x600030, %edx         # imm = 0x600030
callq 0x33e0
movq %rbx, %rdi
popq %rbx
jmp 0x6884
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: configure_request
void configure_request(XEvent *ev)
{
	XConfigureRequestEvent *e = &ev->xconfigurerequest;
	Client *c = window_build_client(e->window);
	if (c && c->manage && c->visible && !c->transient)
	{
		client_update_border(c);
		client_place_spot(c, c->spot, c->monitor, 0);
	}
	else
	if (c)
	{
		XWindowChanges wc;
		if (e->value_mask & CWX) wc.x = e->x;
		if (e->value_mask & CWY) wc.y = e->y;
		if (e->value_mask & CWWidth)  wc.width  = e->width;
		if (e->value_mask & CWHeight) wc.height = e->height;
		if (e->value_mask & CWStackMode)   wc.stack_mode   = e->detail;
		if (e->value_mask & CWBorderWidth) wc.border_width = settings.border;
		XConfigureWindow(display, c->window, e->value_mask, &wc);
	}
	client_free(c);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x7ee4
cmpw $0x0, 0x104(%rbx)
je 0x7e7f
cmpw $0x0, 0x102(%rbx)
je 0x7e7f
cmpq $0x0, 0x90(%rbx)
je 0x7ef4
movq 0x58(%r14), %rdx
testb $0x1, %dl
je 0x7e8f
movl 0x30(%r14), %eax
movl %eax, (%rsp)
testb $0x2, %dl
je 0x7e9c
movl 0x34(%r14), %eax
movl %eax, 0x4(%rsp)
testb $0x4, %dl
je 0x7ea9
movl 0x38(%r14), %eax
movl %eax, 0x8(%rsp)
testb $0x8, %dl
je 0x7eb6
movl 0x3c(%r14), %eax
movl %eax, 0xc(%rsp)
testb $0x40, %dl
je 0x7ec3
movl 0x50(%r14), %eax
movl %eax, 0x20(%rsp)
testb $0x10, %dl
je 0x7ed2
movl 0x72f2(%rip), %eax      # 0xf1c0
movl %eax, 0x10(%rsp)
movq 0x6cd7(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq %rsp, %rcx
callq 0x30c0
movq %rbx, %rdi
callq 0x6884
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x6a78
movl 0x118(%rbx), %esi
movswl 0x100(%rbx), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x6bc5
jmp 0x7ee4
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: configure_notify
void configure_notify(XEvent *e)
{
	Client *c = window_build_client(e->xconfigure.window);
	if (c && c->manage)
	{
		while (XCheckTypedEvent(display, ConfigureNotify, e));
		ewmh_client_list();
		update_bars();
		menu_update();
	}
	client_free(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x7f71
cmpw $0x0, 0x104(%rbx)
je 0x7f71
movq 0x6c72(%rip), %rdi      # 0xebb0
movl $0x16, %esi
movq %r14, %rdx
callq 0x31b0
testl %eax, %eax
jne 0x7f37
callq 0x68a3
callq 0x7a80
movq 0x72e0(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x7f71
callq 0x514f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6884
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: map_request
void map_request(XEvent *e)
{
	Client *c = window_build_client(e->xmaprequest.window);
	if (c && c->manage)
	{
		c->monitor = current_mon;
		Monitor *m = &monitors[c->monitor];
		int spot = have_layout(c->monitor) ? settings.layouts[c->monitor].spot_start: SMART;

		if (spot == CURRENT)
		{
			spot = current_spot;
		}
		if (spot == SMART) // find spot of best fit
		{
			int i; spot = SPOT1; for_spots_rev(i)
				if (c->attr.width <= m->spots[i].w && c->attr.height <= m->spots[i].h)
					{ spot = i; break; }
		}
		client_place_spot(c, spot, c->monitor, 0);
		client_update_border(c);
	}
	if (c) XMapWindow(display, c->window);
	client_free(c);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x803c
cmpw $0x0, 0x104(%rbx)
je 0x802d
movswl 0x729f(%rip), %edx      # 0xf24a
movw %dx, 0x100(%rbx)
movslq %edx, %rax
movl $0x5, %ecx
cmpl %eax, 0x7250(%rip)      # 0xf210
jbe 0x7fcd
movq 0x724f(%rip), %rcx      # 0xf218
movswl (%rcx,%rax,8), %ecx
cmpl $0x4, %ecx
movswl 0x7271(%rip), %esi      # 0xf248
cmovnel %ecx, %esi
cmpl $0x5, %esi
jne 0x801b
movl 0x10(%rbx), %ecx
leaq (%rax,%rax,8), %rax
leaq 0x6bd3(%rip), %rsi      # 0xebc0
leaq (%rsi,%rax,8), %rax
movl $0x4, %esi
movswl 0x4(%rax,%rsi,8), %edi
cmpl %edi, %ecx
jg 0x8009
movswl 0x6(%rax,%rsi,8), %edi
cmpl %edi, 0x14(%rbx)
jle 0x8019
decq %rsi
cmpq $0x1, %rsi
ja 0x7ff6
movl $0x1, %esi
jmp 0x801b
decl %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x6bc5
movq %rbx, %rdi
callq 0x6a78
movq 0x6b7c(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
callq 0x3350
movq %rbx, %rdi
popq %rbx
jmp 0x6884
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: map_notify
void map_notify(XEvent *e)
{
	Client *a = NULL, *c = window_build_client(e->xmap.window);
	if (c && c->manage)
	{
		client_raise_family(c);
		client_update_border(c);
		client_set_focus(c);
		client_free(a);
		ewmh_client_list();
		update_bars();
		menu_update();
	}
	client_free(c);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x809b
cmpw $0x0, 0x104(%rbx)
je 0x809b
movq %rbx, %rdi
callq 0x7081
movq %rbx, %rdi
callq 0x6a78
movq %rbx, %rdi
callq 0x727a
callq 0x68a3
callq 0x7a80
movq 0x71b6(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x809b
callq 0x514f
movq %rbx, %rdi
popq %rbx
jmp 0x6884
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: unmap_notify
void unmap_notify(XEvent *e)
{
	// if this window was focused, find something else
	if (e->xunmap.window == current && !spot_focus_top_window(current_spot, current_mon, current))
	{
		int i; for_spots(i)
			if (spot_focus_top_window(i, current_mon, current)) break;
	}
	ewmh_client_list();
	update_bars();
	menu_update();
}

// Assembly:
pushq %rbx
movq 0x6b0c(%rip), %rdx      # 0xebb8
cmpq %rdx, 0x28(%rdi)
jne 0x80f3
movswl 0x718f(%rip), %edi      # 0xf248
movswl 0x718a(%rip), %esi      # 0xf24a
callq 0x7bca
testq %rax, %rax
jne 0x80f3
movl $0x1, %ebx
movswl 0x7174(%rip), %esi      # 0xf24a
movq 0x6adb(%rip), %rdx      # 0xebb8
movl %ebx, %edi
callq 0x7bca
testq %rax, %rax
jne 0x80f3
leal 0x1(%rbx), %eax
cmpl $0x3, %ebx
movl %eax, %ebx
jne 0x80cf
callq 0x68a3
callq 0x7a80
movq 0x713c(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x8116
popq %rbx
jmp 0x514f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: key_press
void key_press(XEvent *ev)
{
	XKeyEvent *e = &ev->xkey;
	latest_action = e->time;
	KeySym key = XkbKeycodeToKeysym(display, e->keycode, 0, 0);
	unsigned int state = e->state & ~(LockMask|NumlockMask);
	while (XCheckTypedEvent(display, KeyPress, ev));

	if (menu && menu->mb && menu->mb->window == e->window)
	{
		int rc = menubox_keypress(menu->mb, ev);
		menu_update();

		if (rc == -2)
			menu_close();

		if (rc == -1)
			menu_select();

		return;
	}

	Binding *bind = NULL;
	for (int i = 0; i < settings.binding_count && !bind; i++)
		if (settings.bindings[i].key == key && (settings.bindings[i].mod == AnyModifier || settings.bindings[i].mod == state))
			bind = &settings.bindings[i];

	if (bind && bind->act)
	{
		Client *cli = window_build_client(current);
		bind->act(bind->data, bind->num, cli);
		client_free(cli);
		update_bars();
		menu_update();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x38(%rdi), %rax
movq %rax, 0x6c6b(%rip)      # 0xed98
movq 0x6a7c(%rip), %rdi      # 0xebb0
movzbl 0x54(%r14), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x31d0
movq %rax, %rbx
movl 0x50(%r14), %r15d
movl 0x70fd(%rip), %ebp      # 0xf24c
notl %ebp
andl $-0x3, %ebp
movq 0x6a55(%rip), %rdi      # 0xebb0
movl $0x2, %esi
movq %r14, %rdx
callq 0x31b0
testl %eax, %eax
jne 0x8154
movq 0x70cd(%rip), %rax      # 0xf240
testq %rax, %rax
je 0x81d1
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x81d1
movq 0x8(%rdi), %rax
cmpq 0x20(%r14), %rax
jne 0x81d1
movq %r14, %rsi
callq 0x5431
movl %eax, %ebx
movq 0x70a1(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x81b0
callq 0x514f
cmpl $-0x1, %ebx
je 0x828a
cmpl $-0x2, %ebx
jne 0x827f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7396
movl 0x7049(%rip), %eax      # 0xf220
testq %rax, %rax
je 0x8220
andl %r15d, %ebp
movl $0x1, %ecx
movq 0x703d(%rip), %rdx      # 0xf228
xorl %r14d, %r14d
cmpq %rbx, 0x8(%rdx)
jne 0x8206
movl (%rdx), %esi
cmpl %ebp, %esi
cmoveq %rdx, %r14
cmpl $0x8000, %esi           # imm = 0x8000
cmoveq %rdx, %r14
testq %r14, %r14
sete %sil
cmpq %rax, %rcx
jae 0x8226
addq $0x28, %rdx
incq %rcx
testq %r14, %r14
je 0x81ee
jmp 0x8226
xorl %r14d, %r14d
movb $0x1, %sil
testb %sil, %sil
jne 0x827f
cmpq $0x0, 0x10(%r14)
je 0x827f
movq 0x697f(%rip), %rdi      # 0xebb8
callq 0x6148
movq %rax, %rbx
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
movq %rax, %rdx
callq *0x10(%r14)
movq %rbx, %rdi
callq 0x6884
callq 0x7a80
movq 0x6fdc(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x827f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x514f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73f4
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: button_press
void button_press(XEvent *ev)
{
	int i, j; Monitor *m;
	XButtonEvent *e = &ev->xbutton;
	latest_action = e->time;
	Client *c = window_build_client(e->subwindow);
	if (c && c->manage)
		client_activate(c);
	else
	if (settings.title)
		for_monitors(i, m) for_spots(j)
			if (m->bars[i] && m->bars[j]->window == e->subwindow)
				spot_focus_top_window(j, i, None);
	client_free(c);
	XAllowEvents(display, ReplayPointer, latest_action);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x38(%rdi), %rax
movq %rax, 0x6ae6(%rip)      # 0xed98
movq 0x30(%rdi), %rdi
callq 0x6148
testq %rax, %rax
movq %rax, (%rsp)
je 0x82e3
movq %rax, %rbx
cmpw $0x0, 0x104(%rax)
je 0x82e3
movq %rbx, %rdi
callq 0x7081
movq %rbx, %rdi
callq 0x727a
jmp 0x835e
cmpq $0x0, 0x6efd(%rip)      # 0xf1e8
je 0x835e
cmpl $0x0, 0x647c(%rip)      # 0xe770
jle 0x835e
leaq 0x68f3(%rip), %r12      # 0xebf0
xorl %r15d, %r15d
leaq 0x68b9(%rip), %r13      # 0xebc0
leaq (%r15,%r15,8), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
leaq (%rax,%r15,8), %rbp
addq $0x28, %rbp
xorl %ebx, %ebx
cmpq $0x0, (%rbp)
je 0x8342
movq (%r12,%rbx,8), %rax
movq 0x8(%rax), %rax
cmpq 0x30(%r14), %rax
jne 0x8342
leal 0x1(%rbx), %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x7bca
incq %rbx
cmpq $0x3, %rbx
jne 0x8320
incq %r15
movslq 0x641b(%rip), %rax      # 0xe770
addq $0x48, %r12
cmpq %rax, %r15
jl 0x8307
movq (%rsp), %rdi
callq 0x6884
movq 0x6842(%rip), %rdi      # 0xebb0
movq 0x6a23(%rip), %rdx      # 0xed98
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3340
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: client_message
void client_message(XEvent *ev)
{
	XClientMessageEvent *e = &ev->xclient;
	if (e->message_type == atoms[XOAT_EXIT])
	{
		warnx("exit!");
		exit(EXIT_SUCCESS);
	}
	if (e->message_type == atoms[XOAT_RESTART])
	{
		warnx("restart!");
		EXECSH(self);
	}
	Client *c = window_build_client(e->window);
	if (c && c->manage)
	{
		if (e->message_type == atoms[_NET_ACTIVE_WINDOW])
		{
			client_activate(c);
		}
		else
		if (e->message_type == atoms[_NET_CLOSE_WINDOW])
		{
			action_close(NULL, 0, c);
		}
	}
	client_free(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
cmpq 0x690c(%rip), %rax      # 0xeca8
je 0x843d
movq %rdi, %rbx
cmpq 0x6904(%rip), %rax      # 0xecb0
jne 0x83e2
leaq 0x1feb(%rip), %rdi      # 0xa3a0
xorl %eax, %eax
callq 0x30f0
movq 0x6e8d(%rip), %rcx      # 0xf250
leaq 0x1fba(%rip), %rdi      # 0xa384
leaq 0x1fb8(%rip), %rsi      # 0xa389
leaq 0x1fb4(%rip), %rdx      # 0xa38c
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x6148
movq %rax, %r14
testq %rax, %rax
je 0x842e
cmpw $0x0, 0x104(%r14)
je 0x842e
movq 0x28(%rbx), %rax
cmpq 0x68bf(%rip), %rax      # 0xecc8
jne 0x841d
movq %r14, %rdi
callq 0x7081
movq %r14, %rdi
callq 0x727a
jmp 0x842e
cmpq 0x68ac(%rip), %rax      # 0xecd0
jne 0x842e
movq %r14, %rdx
callq 0x56b3
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6884
leaq 0x1f56(%rip), %rdi      # 0xa39a
xorl %eax, %eax
callq 0x30f0
xorl %edi, %edi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: property_notify
void property_notify(XEvent *ev)
{
	XPropertyEvent *e = &ev->xproperty;

	Client *c = window_build_client(e->window);
	if (e->window == root && e->atom == atoms[WM_NAME])
	{
		// root name appears in SPOT1 bar, for status etc
		update_bars();
		menu_update();
	}
	else
	if (c && c->visible && c->manage)
	{
		client_update_border(c);
		if (e->atom == atoms[WM_NAME] || e->atom == atoms[_NET_WM_NAME])
			spot_update_bar(c->spot, c->monitor);
	}
	client_free(c);

	// prevent spam
	while (XCheckTypedWindowEvent(display, ev->xproperty.window, PropertyNotify, ev));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x6148
movq %rax, %r14
movq 0x20(%rbx), %rax
cmpq 0x6d38(%rip), %rax      # 0xf1a8
jne 0x849e
movq 0x28(%rbx), %rax
cmpq 0x68f3(%rip), %rax      # 0xed70
jne 0x849e
callq 0x7a80
movq 0x6db5(%rip), %rax      # 0xf240
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x84eb
callq 0x514f
jmp 0x84eb
testq %r14, %r14
je 0x84eb
cmpw $0x0, 0x102(%r14)
je 0x84eb
cmpw $0x0, 0x104(%r14)
je 0x84eb
movq %r14, %rdi
callq 0x6a78
movq 0x28(%rbx), %rax
cmpq 0x68a4(%rip), %rax      # 0xed70
je 0x84d7
cmpq 0x681b(%rip), %rax      # 0xecf0
jne 0x84eb
movl 0x118(%r14), %edi
movswl 0x100(%r14), %esi
callq 0x77c7
movq %r14, %rdi
callq 0x6884
movq 0x66b6(%rip), %rdi      # 0xebb0
movq 0x20(%rbx), %rsi
movl $0x1c, %edx
movq %rbx, %rcx
callq 0x30d0
testl %eax, %eax
jne 0x84f3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./event.c
// Function: any_event
void any_event(XEvent *e)
{
	Client *c = window_build_client(e->xany.window);
	if (c && c->visible && c->manage)
		client_update_border(c);
	client_free(c);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rdi
callq 0x6148
movq %rax, %rbx
testq %rax, %rax
je 0x8581
cmpw $0x0, 0x102(%rbx)
je 0x8581
cmpw $0x0, 0x104(%rbx)
je 0x8581
movq %rbx, %rdi
callq 0x6a78
movq %rbx, %rdi
popq %rbx
jmp 0x6884
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./action.c
// Function: action_move
void action_move(void *data, int num, Client *cli)
{
	if (!cli) return;
	client_place_spot(cli, num, cli->monitor, 1);
	client_raise_family(cli);
	current_spot = cli->spot; current_mon = cli->monitor;
	spot_warp_pointer(cli->spot, cli->monitor);
}

// Assembly:
testq %rdx, %rdx
je 0x85d1
pushq %rbx
movq %rdx, %rbx
movswl 0x100(%rdx), %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x6bc5
movq %rbx, %rdi
callq 0x7081
movq 0x118(%rbx), %rdi
movw %di, 0x6c8b(%rip)       # 0xf248
movswl 0x100(%rbx), %esi
movw %si, 0x6c7f(%rip)       # 0xf24a
popq %rbx
jmp 0x7abe
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./action.c
// Function: action_find_or_start
void action_find_or_start(void *data, int num, Client *cli)
{
	int i; Client *c; char *class = data;
	for_windows(i, c)
		if (c->visible && c->manage && c->class && strcasestr(c->class, class))
			{ client_activate(c); spot_warp_pointer(c->spot, c->monitor); return; }
	exec_cmd(class);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x606d
movswq 0x6790(%rip), %r15      # 0xeda0
testq %r15, %r15
jle 0x8660
xorl %r12d, %r12d
leaq 0x6781(%rip), %r13      # 0xeda0
movq 0x8(%r13,%r12,8), %r14
testq %r14, %r14
je 0x8658
cmpw $0x0, 0x102(%r14)
je 0x8658
cmpw $0x0, 0x104(%r14)
je 0x8658
movq 0x128(%r14), %rdi
testq %rdi, %rdi
je 0x8658
movq %rbx, %rsi
callq 0x3060
testq %rax, %rax
jne 0x8671
incq %r12
cmpq %r12, %r15
jne 0x861f
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x590f
movq %r14, %rdi
callq 0x7081
movq %r14, %rdi
callq 0x727a
movl 0x118(%r14), %edi
movswl 0x100(%r14), %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7abe
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./action.c
// Function: action_move_monitor
void action_move_monitor(void *data, int num, Client *cli)
{
	if (!cli) return;
	cli->monitor = monitor_choose_by_direction(current_mon, num);
	client_place_spot(cli, cli->spot, cli->monitor, 1);
	client_raise_family(cli);
	current_mon = cli->monitor;
	spot_warp_pointer(cli->spot, cli->monitor);
}

// Assembly:
testq %rdx, %rdx
je 0x86f2
pushq %rbx
movq %rdx, %rbx
movswl 0x6b9c(%rip), %edi      # 0xf24a
callq 0x596a
movw %ax, 0x100(%rbx)
movl 0x118(%rbx), %esi
movswl %ax, %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x6bc5
movq %rbx, %rdi
callq 0x7081
movswl 0x100(%rbx), %esi
movw %si, 0x6b64(%rip)       # 0xf24a
movl 0x118(%rbx), %edi
popq %rbx
jmp 0x7abe
retq
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/./action.c
// Function: action_focus_monitor
void action_focus_monitor(void *data, int num, Client *cli)
{
	int i, mon = monitor_choose_by_direction(current_mon, num);
	if (!spot_focus_top_window(current_spot, mon, None))
		for_spots(i) if (spot_focus_top_window(i, mon, None)) break;
	spot_warp_pointer(current_spot, current_mon);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movswl 0x6b4c(%rip), %edi      # 0xf24a
callq 0x596a
movl %eax, %ebx
movswl 0x6b3c(%rip), %edi      # 0xf248
movl %eax, %esi
xorl %edx, %edx
callq 0x7bca
testq %rax, %rax
jne 0x873e
movl $0x1, %r14d
movl %r14d, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x7bca
testq %rax, %rax
jne 0x873e
leal 0x1(%r14), %eax
cmpl $0x3, %r14d
movl %eax, %r14d
jne 0x8720
movswl 0x6b03(%rip), %edi      # 0xf248
movswl 0x6afe(%rip), %esi      # 0xf24a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7abe
// File: /workspace/github_c_makefile_star2_O1/seanpringle[P]xoat/xoat.c
// Function: oops
int oops(Display *d, XErrorEvent *ee)
{
	if (ee->error_code == BadWindow
		|| (ee->request_code == X_SetInputFocus   && ee->error_code == BadMatch)
		|| (ee->request_code == X_ConfigureWindow && ee->error_code == BadMatch)
		|| (ee->request_code == X_ConfigureWindow && ee->error_code == BadValue)
		|| (ee->request_code == X_GrabButton      && ee->error_code == BadAccess)
		|| (ee->request_code == X_GrabKey         && ee->error_code == BadAccess)
		) return 0;
	fprintf(stderr, "error: request code=%d, error code=%d\n", ee->request_code, ee->error_code);
	return xerror(display, ee);
}

// Assembly:
pushq %rbx
movzbl 0x20(%rsi), %ecx
cmpl $0x3, %ecx
je 0x9a30
movq %rsi, %rbx
movzbl 0x21(%rsi), %edx
movl %edx, %eax
xorb $0x2a, %al
movl %ecx, %esi
xorb $0x8, %sil
orb %al, %sil
je 0x9a30
cmpl $0x8, %ecx
sete %al
cmpl $0xc, %edx
sete %sil
cmpl $0x2, %ecx
sete %dil
orb %al, %dil
testb %sil, %dil
jne 0x9a30
movl %edx, %eax
xorb $0x1c, %al
movl %ecx, %esi
xorb $0xa, %sil
orb %al, %sil
je 0x9a30
cmpl $0xa, %ecx
jne 0x9a34
cmpb $0x21, %dl
jne 0x9a34
xorl %eax, %eax
popq %rbx
retq
movq 0x45ad(%rip), %rax      # 0xdfe8
movq (%rax), %rdi
leaq 0x10be(%rip), %rsi      # 0xab03
xorl %eax, %eax
callq 0x3660
movq 0x580d(%rip), %rax      # 0xf260
movq 0x5156(%rip), %rdi      # 0xebb0
movq %rbx, %rsi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c, unsigned long long *clen,
	const unsigned char *m, unsigned long long mlen,
	const unsigned char *ad, unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k
	)
{
	block TA = _mm_setzero_si128(), TE;

	Setup(k);
#if(ADP==Para)
	if ((uint32)adlen > 0){
		TA = AFunc(ad, (uint32)adlen);
	}
	TE = EFunc(npub, CRYPTO_NPUBBYTES, m, (uint32)mlen, CRYPTO_ABYTES, c);
	TE = _mm_xor_si128(TE, TA);
#else
	if ((uint32)adlen > 0){
		TA = AFuncS(ad, (uint32)adlen);
	}
	TE = EFunc(npub, CRYPTO_NPUBBYTES, TA, m, (uint32)mlen, CRYPTO_ABYTES, c);
#endif
	memcpy(c + mlen, (uint8*)&TE, CRYPTO_ABYTES);
	*clen = mlen + CRYPTO_ABYTES;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rsp), %r13
movq 0x5028(%rip), %rax      # 0x7ff0
vmovdqa (%rax), %xmm0
vaesenc 0x10(%rax), %xmm0, %xmm0
vaesenc 0x20(%rax), %xmm0, %xmm0
vaesenc 0x30(%rax), %xmm0, %xmm0
vaesenc 0x40(%rax), %xmm0, %xmm0
vaesenc 0x50(%rax), %xmm0, %xmm0
vaesenc 0x60(%rax), %xmm0, %xmm0
vaesenc 0x70(%rax), %xmm0, %xmm0
vaesenc 0x80(%rax), %xmm0, %xmm0
vaesenc 0x90(%rax), %xmm0, %xmm0
vaesenc 0xa0(%rax), %xmm0, %xmm0
vaesenc 0xb0(%rax), %xmm0, %xmm0
vaesenc 0xc0(%rax), %xmm0, %xmm0
vaesenc 0xd0(%rax), %xmm0, %xmm0
vaesenclast 0xe0(%rax), %xmm0, %xmm0
movq 0x4fa4(%rip), %rax      # 0x7fe0
vmovdqa %xmm0, (%rax)
testl %r9d, %r9d
je 0x3052
movq %r8, %rdi
movl %r9d, %esi
callq 0x1080
jmp 0x3056
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq %r13, %rdi
movl $0xc, %esi
movq %r12, %rdx
movl %ebx, %ecx
movl $0x10, %r8d
movq %r15, %r9
callq 0x1050
vpxor (%rsp), %xmm0, %xmm0
vmovdqu %xmm0, (%r15,%rbx)
addq $0x10, %rbx
movq %rbx, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
	unsigned char *m, unsigned long long *mlen,
	unsigned char *nsec,
	const unsigned char *c, unsigned long long clen,
	const unsigned char *ad, unsigned long long adlen,
	const unsigned char *npub,
	const unsigned char *k
	)
{
	uint8 loctag[BLOCK];
	block TA = _mm_setzero_si128(), TE;

	*mlen = clen - CRYPTO_ABYTES;
	Setup(k);
#if (ADP==Para)
	if ((uint32)adlen > 0){
		TA = AFunc(ad, (uint32)adlen);
	}
	TE = DFunc(npub, CRYPTO_NPUBBYTES, c,
		(uint32)clen - CRYPTO_ABYTES, CRYPTO_ABYTES, m);
	TE = _mm_xor_si128(TE, TA);
#else 
	if ((uint32)adlen > 0){
		TA = AFuncS(ad, (uint32)adlen);
	}
	TE = DFunc(npub, CRYPTO_NPUBBYTES, TA, c,
		(uint32)clen - CRYPTO_ABYTES, CRYPTO_ABYTES, m);
#endif
	memcpy(loctag, (uint8*)&TE, CRYPTO_ABYTES);
	if (memcmp(loctag, c + (uint32)*mlen, CRYPTO_ABYTES) != 0){//non-constant-time compare
		return TAG_UNMATCH; //-1
	}
	return TAG_MATCH; //0
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x58(%rsp), %r13
movl 0x50(%rsp), %esi
leaq -0x10(%r8), %rax
movq %rax, (%r14)
movq 0x4f28(%rip), %rax      # 0x7ff0
vmovdqa (%rax), %xmm0
vaesenc 0x10(%rax), %xmm0, %xmm0
vaesenc 0x20(%rax), %xmm0, %xmm0
vaesenc 0x30(%rax), %xmm0, %xmm0
vaesenc 0x40(%rax), %xmm0, %xmm0
vaesenc 0x50(%rax), %xmm0, %xmm0
vaesenc 0x60(%rax), %xmm0, %xmm0
vaesenc 0x70(%rax), %xmm0, %xmm0
vaesenc 0x80(%rax), %xmm0, %xmm0
vaesenc 0x90(%rax), %xmm0, %xmm0
vaesenc 0xa0(%rax), %xmm0, %xmm0
vaesenc 0xb0(%rax), %xmm0, %xmm0
vaesenc 0xc0(%rax), %xmm0, %xmm0
vaesenc 0xd0(%rax), %xmm0, %xmm0
vaesenclast 0xe0(%rax), %xmm0, %xmm0
movq 0x4ea4(%rip), %rax      # 0x7fe0
vmovdqa %xmm0, (%rax)
testl %esi, %esi
je 0x314e
movq %r9, %rdi
callq 0x1080
jmp 0x3152
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
addl $-0x10, %r15d
movq %r13, %rdi
movl $0xc, %esi
movq %rbx, %rdx
movl %r15d, %ecx
movl $0x10, %r8d
movq %r12, %r9
callq 0x1060
vpxor (%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
movl (%r14), %eax
vmovdqa 0x10(%rsp), %xmm0
vpxor (%rbx,%rax), %xmm0, %xmm0
xorl %eax, %eax
vptest %xmm0, %xmm0
setne %al
negl %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]init/stop.c
// Function: main
int main(int argc, char **argv) {
  if (argc == 2 && !strcmp(argv[1], "halt"))
    return reboot(RB_HALT_SYSTEM);
  else if (argc == 2 && !strcmp(argv[1], "kexec"))
    return reboot(RB_KEXEC);
  else if (argc == 2 && !strcmp(argv[1], "poweroff"))
    return fork() > 0 ? pause() : reboot(RB_POWER_OFF);
  else if (argc == 2 && !strcmp(argv[1], "reboot"))
    return reboot(RB_AUTOBOOT);
  else if (argc == 2 && !strcmp(argv[1], "suspend"))
    return reboot(RB_SW_SUSPEND);

  fprintf(stderr, "\
Usage: %s ACTION\n\
Actions:\n\
  halt      halt the machine\n\
  kexec     jump to a new kernel loaded for kexec\n\
  poweroff  switch off the machine\n\
  reboot    restart the machine\n\
  suspend   hibernate the machine to disk\n\
All actions are performed immediately without flushing buffers or a\n\
graceful shutdown. Data may be lost on unsynced mounted filesystems.\n\
", argv[0]);
  return EX_USAGE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x1240
movq 0x8(%rbx), %r14
leaq 0xe4d(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x1216
leaq 0xe3f(%rip), %rsi       # 0x2009
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x121d
leaq 0xe32(%rip), %rsi       # 0x200f
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x1224
leaq 0xe28(%rip), %rsi       # 0x2018
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x1239
leaq 0xe1c(%rip), %rsi       # 0x201f
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
jne 0x1240
movl $0xd000fce2, %edi       # imm = 0xD000FCE2
jmp 0x125a
movl $0xcdef0123, %edi       # imm = 0xCDEF0123
jmp 0x125a
movl $0x45584543, %edi       # imm = 0x45584543
jmp 0x125a
callq 0x1070
testl %eax, %eax
jle 0x1255
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1050
movl $0x1234567, %edi        # imm = 0x1234567
jmp 0x125a
movq %rbx, %rdi
callq 0x1090
movl $0x40, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4321fedc, %edi       # imm = 0x4321FEDC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha1_check.c
// Function: main
int main(int argc, char **argv)
{
	int fd = STDIN_FILENO;
	if (argc > 1 && (fd = open(argv[1], O_RDONLY)) < 0) {
		fprintf(stderr, "%s : cannot access '%s'\n", argv[0], argv[1]);
		exit(EXIT_FAILURE);
	}

	struct sha1_ctx ctx;
	sha1_init(&ctx);

	int total = 0;
	int rd = 0;
	while ((rd = read(fd, buffer + total, CHUNK_SIZE - total)) > 0) {
		total += rd;
		if (total >= CHUNK_SIZE) {
			sha1_update(&ctx, buffer);
			total = 0;
		}
	}
	sha1_update_last(&ctx, buffer, total);

	for (int i = 0; i < WORD_CNT; ++i)
		printf("%08x", ctx.h[i]);
	printf("\n");

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %ebx, %ebx
cmpl $0x2, %edi
jl 0x11fa
movq %rsi, %r14
movq 0x8(%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1080
movl %eax, %ebx
testl %eax, %eax
js 0x12a5
movq %rsp, %rdi
callq 0x12b4
leaq 0x2e67(%rip), %r14      # 0x4070
movl $0x40, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1050
xorl %r13d, %r13d
testl %eax, %eax
jle 0x1255
movq %rsp, %r15
addl %r13d, %eax
cmpl $0x40, %eax
jl 0x1237
movq %r15, %rdi
movq %r14, %rsi
callq 0x12ce
xorl %eax, %eax
movl %eax, %r13d
movl %eax, %r12d
leaq (%r14,%r12), %rsi
movl $0x40, %edx
subl %eax, %edx
movl %ebx, %edi
callq 0x1050
testl %eax, %eax
jg 0x1222
jmp 0x1258
xorl %r12d, %r12d
leaq 0x2e11(%rip), %rsi      # 0x4070
movq %rsp, %rdi
movq %r12, %rdx
callq 0x145d
leaq 0xdac(%rip), %rbx       # 0x201d
xorl %r14d, %r14d
movl (%rsp,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
incq %r14
cmpq $0x5, %r14
jne 0x1274
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%r14), %rsi
movq %r14, %rdi
callq 0x10b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha1.c
// Function: sha1_update_last
void sha1_update_last(struct sha1_ctx *ctx, byte_t *chunk, len_t len)
{
	ctx->len += len;
	len_t bit_len = ctx->len * 8;

	byte_t padding[64];
	memset(padding, 0, sizeof(padding));

	memcpy(padding, chunk, len);
	*(padding + len) = 0x80;

	if (len >= 56) {
		_sha1_iterate(ctx, padding);
		memset(padding, 0, sizeof(padding));
	}

	byte_t *ptr = padding + 56;
	for (int i = 7; i >= 0; --i) {
		*ptr = (bit_len >> 8 * i) & 0xFF;
		++ptr;
	}
	_sha1_iterate(ctx, padding);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq %rdx, %r15
movq %r15, 0x18(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x1070
movb $-0x80, (%rsp,%r14)
cmpq $0x37, %r14
jbe 0x14c0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12de
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
shlq $0x3, %r15
movl $0x38, %ecx
leaq 0x38(%rsp), %rax
movq %r15, %rdx
shrq %cl, %rdx
movb %dl, (%rax)
addq $-0x8, %rcx
incq %rax
cmpq $-0x8, %rcx
jne 0x14ce
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12de
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha1.c
// Function: sha1_offline
void sha1_offline(struct sha1_ctx *ctx, byte_t *msg, len_t len)
{
	sha1_init(ctx);

	while (len >= 64) {
		sha1_update(ctx, msg);

		msg += 64;
		len -= 64;
	}

	sha1_update_last(ctx, msg, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movaps 0xb23(%rip), %xmm0      # 0x2030
movups %xmm0, (%rdi)
movl $0xc3d2e1f0, 0x10(%rdi) # imm = 0xC3D2E1F0
movq $0x0, 0x18(%rdi)
cmpq $0x40, %rdx
jb 0x1543
movq %r15, %rdi
movq %r14, %rsi
callq 0x12de
addq $0x40, 0x18(%r15)
addq $0x40, %r14
addq $-0x40, %rbx
cmpq $0x3f, %rbx
ja 0x1525
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x145d
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_debug
static int db_debug (lua_State *L) {
  for (;;) {
    char buffer[250];
    lua_writestringerror("%s", "lua_debug> ");
    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
        strcmp(buffer, "cont\n") == 0)
      return 0;
    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
        lua_pcall(L, 0, 0, 0))
      lua_writestringerror("%s\n", lua_tostring(L, -1));
    lua_settop(L, 0);  /* remove eventual returns */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x29a37(%rip), %rbp     # 0x2eff0
movq (%rbp), %rsi
leaq 0x1d74d(%rip), %rdi     # 0x22d11
callq 0x51c0
movq (%rbp), %rdi
callq 0x5360
movq 0x299f7(%rip), %r14     # 0x2efd0
movq (%r14), %rdx
movq %rsp, %rdi
movl $0xfa, %esi
callq 0x5260
testq %rax, %rax
je 0x56d1
leaq 0x1d724(%rip), %r13     # 0x22d1d
movq %rsp, %r15
pushq $0x6
popq %r12
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5390
testl %eax, %eax
je 0x56d1
movq %r15, %rdi
callq 0x5150
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
leaq 0x1d6f5(%rip), %rcx     # 0x22d23
xorl %r8d, %r8d
callq 0x14e35
testl %eax, %eax
jne 0x5652
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6e8a
testl %eax, %eax
je 0x5695
movq %r14, %r15
movq %r12, %r14
movq %r13, %r12
movq (%rbp), %r13
movq %rbx, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x6249
movq %r13, %rdi
movq %r12, %r13
movq %r14, %r12
movq %r15, %r14
movq %rsp, %r15
leaq 0x1cb42(%rip), %rsi     # 0x221c4
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movq (%rbp), %rdi
callq 0x5360
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d51
movq (%rbp), %rsi
leaq 0x1d667(%rip), %rdi     # 0x22d11
callq 0x51c0
movq (%rbp), %rdi
callq 0x5360
movq (%r14), %rdx
movq %r15, %rdi
movl $0xfa, %esi
callq 0x5260
testq %rax, %rax
jne 0x5600
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: getkey
int getkey(int *is_end_of_seq) {

  // Make reading from stdin non-blocking.
  int flags = fcntl(STDIN_FILENO, F_GETFL);
  fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);

  // We care about two cases:
  // Case 1: A sequence of the form 27, 91, X; return X.
  // Case 2: For any other sequence, return each int separately.

  *is_end_of_seq = 0;
  int ch = getchar();
  if (ch == 27) {
    int next = getchar();
    if (next == 91) {
      *is_end_of_seq = 1;
      ch = getchar();
      goto end;
    }
    // If we get here, then we're not in a 27, 91, X sequence.
    ungetc(next, stdin);
  }

end:

  // Turn off non-blocking I/O. On some systems, leaving stdin
  // non-blocking will also leave stdout non-blocking, which can
  // cause printing errors.
  fcntl(STDIN_FILENO, F_SETFL, flags);
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %edi, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x5110
movl %eax, %ebx
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x5110
movl $0x0, (%r14)
callq 0x52a0
movl %eax, %r15d
cmpl $0x1b, %eax
jne 0x588a
callq 0x52a0
cmpl $0x5b, %eax
jne 0x5873
movl $0x1, (%r14)
callq 0x52a0
movl %eax, %r15d
jmp 0x588a
movq 0x29756(%rip), %rcx     # 0x2efd0
movq (%rcx), %rsi
movl %eax, %edi
callq 0x5380
movl $0x1b, %r15d
xorl %edi, %edi
movl $0x4, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x5110
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq