LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x89ae(%rip), %rcx      # 0xf240
movq 0x648(%rcx), %rax
testq %rax, %rax
je 0x68eb
pushq %rbx
movq 0x68(%rax), %rsi
movl 0x54(%rax), %edx
cmpl $0x0, (%rsi,%rdx,4)
je 0x68fa
movq 0x60(%rax), %rsi
movslq (%rsi,%rdx,4), %rdx
testq %rdx, %rdx
js 0x68fa
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rdi
callq 0x56d6
testq %rax, %rax
je 0x68ec
movq %rax, %rbx
cmpw $0x0, 0x104(%rax)
je 0x68e1
movq %rbx, %rdi
callq 0x6809
movq %rbx, %rdi
callq 0x5dae
jmp 0x690c
retq
movq 0x894d(%rip), %rax      # 0xf240
movq 0x648(%rax), %rax
movq 0x70(%rax), %rax
movq 0x50(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x690c
callq 0x4ef3
popq %rbx
jmp 0x6833
// File: /workspace/github_c_makefile_star2_O2/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), %r15
movq %r15, %rdi
callq 0x3250
movq %rsp, %rcx
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3250
movq %rsp, %r12
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
xorl %r13d, %r13d
movsbq (%r15,%r13), %rbx
testq %rbx, %rbx
je 0x6986
callq 0x34e0
movq (%rax), %rax
movb (%rax,%rbx,4), %al
movq -0x30(%rbp), %rcx
movb %al, (%rcx,%r13)
incq %r13
jmp 0x6964
xorl %r15d, %r15d
movsbq (%r14,%r15), %rbx
testq %rbx, %rbx
je 0x69a7
callq 0x34e0
movq (%rax), %rax
movb (%rax,%rbx,4), %al
movb %al, (%r12,%r15)
incq %r15
jmp 0x6989
movq -0x30(%rbp), %rdi
movq %r12, %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_O2/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 $0x48, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x7cec(%rip), %rdi      # 0xebb0
movq 0x82dd(%rip), %rsi      # 0xf1a8
leaq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x34(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x24(%rsp), %r9
callq 0x3580
testl %eax, %eax
je 0x6fd9
movslq %ebp, %rax
movslq %ebx, %rcx
imulq $0x48, %rax, %rax
leaq 0x7ca6(%rip), %rdx      # 0xebc0
addq %rax, %rdx
leaq (%rdx,%rcx,8), %rdx
addq $0x8, %rdx
movswl (%rdx), %eax
movl 0x28(%rsp), %ecx
cmpl %eax, %ecx
sete %r8b
movzwl 0x4(%rdx), %edi
cmpw $0x1, %di
sete %r9b
movw $0x1, %si
testb %r9b, %r8b
jne 0x6f65
movswl %di, %r8d
leal (%r8,%rax), %esi
leal 0x1(%rcx), %r9d
cmpl %ecx, %esi
cmovlel %esi, %r9d
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %edi, %esi
cmpl %ecx, %r9d
jle 0x6fa3
movswl 0x2(%rdx), %ecx
movl 0x24(%rsp), %edi
cmpl %ecx, %edi
sete %r8b
movzwl 0x6(%rdx), %edx
cmpw $0x1, %dx
sete %r9b
testb %r9b, %r8b
jne 0x6fd9
movswl %dx, %edx
addl %ecx, %edx
leal 0x1(%rdi), %r8d
cmpl %edi, %edx
cmovlel %edx, %r8d
cmpl %ecx, %edi
cmovlel %ecx, %edi
cmpl %edi, %r8d
jg 0x6fd9
movswl %si, %r8d
jmp 0x6fa7
movswl 0x2(%rdx), %ecx
movq 0x7c02(%rip), %rdi      # 0xebb0
movq 0x81f3(%rip), %rdx      # 0xf1a8
addl %r8d, %eax
addl $-0xa, %eax
addl $0xa, %ecx
andl $0x0, (%rsp)
movl %ecx, 0x10(%rsp)
movl %eax, 0x8(%rsp)
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3450
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5607
movl 0x7da9(%rip), %edx      # 0xeda0
xorl %eax, %eax
testw %dx, %dx
cmovlel %eax, %edx
movslq %r14d, %rcx
movzwl %dx, %edx
leaq 0x7d94(%rip), %rsi      # 0xeda0
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x705b
movq 0x8(%rsi,%rdi,8), %r14
testq %r14, %r14
je 0x7043
cmpq %rbx, (%r14)
je 0x7043
cmpw $0x0, 0x104(%r14)
je 0x7043
cmpq %rcx, 0x118(%r14)
jne 0x7043
movswl 0x100(%r14), %r8d
cmpl %ebp, %r8d
je 0x7048
incq %rdi
jmp 0x700e
movq %r14, %rdi
callq 0x6580
movq %r14, %rdi
callq 0x672d
movq (%r14), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6fe0
movq %rax, %rbx
testq %rax, %rax
jne 0x70a6
andq $0x0, 0x7b3a(%rip)      # 0xebb8
movw %r14w, 0x81c4(%rip)     # 0xf24a
movw %bp, 0x81bb(%rip)       # 0xf248
callq 0x6e79
movq 0x7b17(%rip), %rdi      # 0xebb0
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x33f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x48, %rdi, %rcx
leaq 0x7b02(%rip), %rsi      # 0xebc0
addq %rcx, %rsi
movb $0x1, %cl
cmpl %edi, 0x8147(%rip)      # 0xf210
jbe 0x70db
movq 0x8146(%rip), %rcx      # 0xf218
cmpw $0x1, 0x2(%rcx,%rdi,8)
sete %cl
movzwl 0x4(%rsi), %edi
cmpw 0x6(%rsi), %di
jge 0x70fc
decl %edx
cmpl $0x3, %edx
ja 0x7121
leaq 0x2f51(%rip), %rax      # 0xa044
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
decl %edx
cmpl $0x3, %edx
ja 0x7121
leaq 0x2f2a(%rip), %rax      # 0xa034
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzbl %cl, %ecx
pushq $0x2
popq %rax
subl %ecx, %eax
retq
movzbl %cl, %eax
incl %eax
retq
pushq $0x2
jmp 0x7128
pushq $0x3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5607
movslq %r14d, %r14
xorl %r15d, %r15d
movzwl 0x7be7(%rip), %eax      # 0xeda0
leaq 0x7be0(%rip), %r12      # 0xeda0
movswq %ax, %rcx
cmpq %rcx, %r15
jge 0x7205
movq 0x8(%r12,%r15,8), %rdi
testq %rdi, %rdi
je 0x7200
cmpw $0x0, 0x104(%rdi)
je 0x7200
cmpq %r14, 0x118(%rdi)
jne 0x7200
movswl 0x100(%rdi), %ecx
cmpl %ebp, %ecx
jne 0x7200
movq %rbx, %rsi
callq 0x64d5
movzwl 0x7ba0(%rip), %eax      # 0xeda0
incq %r15
jmp 0x71c0
movswl (%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x7235
cmpw $0x0, 0x104(%rbx)
je 0x7235
movq (%rbx), %rdi
callq 0x55f3
movq %rbx, %rdi
popq %rbx
jmp 0x5dae
// File: /workspace/github_c_makefile_star2_O2/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 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x72e0
cmpw $0x0, 0x104(%rbx)
je 0x727b
cmpw $0x0, 0x102(%rbx)
je 0x727b
cmpq $0x0, 0x90(%rbx)
je 0x72f0
movq 0x58(%r14), %rdx
testb $0x1, %dl
je 0x728b
movl 0x30(%r14), %eax
movl %eax, (%rsp)
testb $0x2, %dl
je 0x7298
movl 0x34(%r14), %eax
movl %eax, 0x4(%rsp)
testb $0x4, %dl
je 0x72a5
movl 0x38(%r14), %eax
movl %eax, 0x8(%rsp)
testb $0x8, %dl
je 0x72b2
movl 0x3c(%r14), %eax
movl %eax, 0xc(%rsp)
testb $0x40, %dl
je 0x72bf
movl 0x50(%r14), %eax
movl %eax, 0x20(%rsp)
testb $0x10, %dl
je 0x72ce
movl 0x7ef6(%rip), %eax      # 0xf1c0
movl %eax, 0x10(%rsp)
movq 0x78db(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
movq %rsp, %rcx
callq 0x30c0
movq %rbx, %rdi
callq 0x5dae
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x5f9b
movl 0x118(%rbx), %esi
movswl 0x100(%rbx), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x60e9
jmp 0x72e0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x735a
cmpw $0x0, 0x104(%rbx)
je 0x735a
pushq $0x16
popq %rbp
movq 0x7873(%rip), %rdi      # 0xebb0
movl %ebp, %esi
movq %r14, %rdx
callq 0x31b0
testl %eax, %eax
jne 0x7336
callq 0x5dcd
callq 0x6e79
callq 0x681b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5dae
// File: /workspace/github_c_makefile_star2_O2/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 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x7421
cmpw $0x0, 0x104(%rbx)
je 0x7412
movswl 0x7eb9(%rip), %edx      # 0xf24a
movw %dx, 0x100(%rbx)
movslq %edx, %rcx
cmpl %ecx, 0x7e6f(%rip)      # 0xf210
jbe 0x73c1
movq 0x7e6e(%rip), %rax      # 0xf218
movzwl (%rax,%rcx,8), %eax
cmpw $0x4, %ax
jne 0x73bb
movzwl 0x7e8d(%rip), %eax      # 0xf248
cmpw $0x5, %ax
jne 0x73fd
movl 0x10(%rbx), %eax
imulq $0x48, %rcx, %rsi
leaq 0x77f1(%rip), %rcx      # 0xebc0
addq %rsi, %rcx
pushq $0x3
popq %rdi
pushq $0x1
popq %rsi
movq %rdi, %r8
subq $0x1, %rdi
jb 0x7400
movswl 0x14(%rcx,%rdi,8), %r9d
cmpl %r9d, %eax
jg 0x73d8
movswl 0x16(%rcx,%rdi,8), %r9d
cmpl %r9d, 0x14(%rbx)
jg 0x73d8
movl %r8d, %esi
jmp 0x7400
movswl %ax, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x60e9
movq %rbx, %rdi
callq 0x5f9b
movq 0x7797(%rip), %rdi      # 0xebb0
movq (%rbx), %rsi
callq 0x3350
movq %rbx, %rdi
popq %rbx
jmp 0x5dae
// File: /workspace/github_c_makefile_star2_O2/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 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x746d
cmpw $0x0, 0x104(%rbx)
je 0x746d
movq %rbx, %rdi
callq 0x6580
movq %rbx, %rdi
callq 0x5f9b
movq %rbx, %rdi
callq 0x672d
callq 0x5dcd
callq 0x6e79
callq 0x681b
movq %rbx, %rdi
popq %rbx
jmp 0x5dae
// File: /workspace/github_c_makefile_star2_O2/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 0x28(%rdi), %rdx
cmpq 0x7736(%rip), %rdx      # 0xebb8
jne 0x74c0
movswl 0x7dbd(%rip), %edi      # 0xf248
movswl 0x7db8(%rip), %esi      # 0xf24a
callq 0x6fe0
testq %rax, %rax
jne 0x74c0
pushq $0x1
popq %rbx
cmpl $0x4, %ebx
je 0x74c0
movswl 0x7d9f(%rip), %esi      # 0xf24a
movq 0x7706(%rip), %rdx      # 0xebb8
movl %ebx, %edi
callq 0x6fe0
incl %ebx
testq %rax, %rax
je 0x749f
callq 0x5dcd
callq 0x6e79
popq %rbx
jmp 0x681b
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0x38(%rdi), %rax
movq %rax, 0x78b2(%rip)      # 0xed98
movq 0x76c3(%rip), %rdi      # 0xebb0
movzbl 0x54(%r14), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x31d0
movq %rax, %rbx
movl 0x50(%r14), %r12d
movl 0x7d43(%rip), %r15d     # 0xf24c
notl %r15d
andl $-0x3, %r15d
pushq $0x2
popq %rbp
movq 0x7696(%rip), %rdi      # 0xebb0
movl %ebp, %esi
movq %r14, %rdx
callq 0x31b0
testl %eax, %eax
jne 0x7513
movq 0x7d11(%rip), %rax      # 0xf240
testq %rax, %rax
je 0x7578
movq 0x648(%rax), %rdi
testq %rdi, %rdi
je 0x7578
movq 0x8(%rdi), %rax
cmpq 0x20(%r14), %rax
jne 0x7578
movq %r14, %rsi
callq 0x4a58
movl %eax, %ebx
callq 0x681b
cmpl $-0x1, %ebx
je 0x760f
cmpl $-0x2, %ebx
jne 0x7606
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6833
andl %r12d, %r15d
movl 0x7c9f(%rip), %eax      # 0xf220
movq 0x7ca0(%rip), %rcx      # 0xf228
xorl %edx, %edx
xorl %r14d, %r14d
cmpq %rax, %rdx
jae 0x75c2
testq %r14, %r14
jne 0x75c2
cmpq %rbx, 0x8(%rcx)
jne 0x75b6
movl (%rcx), %esi
movq %rcx, %r14
cmpl %r15d, %esi
je 0x75aa
xorl %r14d, %r14d
cmpl $0x8000, %esi           # imm = 0x8000
cmoveq %rcx, %r14
jmp 0x75b9
xorl %r14d, %r14d
incq %rdx
addq $0x28, %rcx
jmp 0x758d
testq %r14, %r14
je 0x7606
cmpq $0x0, 0x10(%r14)
je 0x7606
movq 0x75e3(%rip), %rdi      # 0xebb8
callq 0x56d6
movq %rax, %rbx
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
movq %rax, %rdx
callq *0x10(%r14)
movq %rbx, %rdi
callq 0x5dae
callq 0x6e79
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x681b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x688b
// File: /workspace/github_c_makefile_star2_O2/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, 0x7763(%rip)      # 0xed98
movq 0x30(%rdi), %rdi
callq 0x56d6
testq %rax, %rax
movq %rax, (%rsp)
je 0x765b
cmpw $0x0, 0x104(%rax)
je 0x765b
movq %rax, %rdi
callq 0x6809
jmp 0x76c9
cmpq $0x0, 0x7b85(%rip)      # 0xf1e8
je 0x76c9
leaq 0x7584(%rip), %r12      # 0xebf0
xorl %r15d, %r15d
leaq 0x754a(%rip), %r13      # 0xebc0
movslq 0x70f3(%rip), %rax      # 0xe770
cmpq %rax, %r15
jge 0x76c9
imulq $0x48, %r15, %rax
addq %r13, %rax
leaq (%rax,%r15,8), %rbp
addq $0x28, %rbp
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x76c0
cmpq $0x0, (%rbp)
je 0x76bb
movq (%r12,%rbx,8), %rax
movq 0x8(%rax), %rax
cmpq 0x30(%r14), %rax
jne 0x76bb
leal 0x1(%rbx), %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x6fe0
incq %rbx
jmp 0x7693
incq %r15
addq $0x48, %r12
jmp 0x7676
movq (%rsp), %rdi
callq 0x5dae
movq 0x74d7(%rip), %rdi      # 0xebb0
movq 0x76b8(%rip), %rdx      # 0xed98
pushq $0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3340
// File: /workspace/github_c_makefile_star2_O2/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 0x75a3(%rip), %rax      # 0xeca8
je 0x779e
movq %rdi, %rbx
cmpq 0x759b(%rip), %rax      # 0xecb0
jne 0x774b
leaq 0x2cba(%rip), %rdi      # 0xa3d8
xorl %eax, %eax
callq 0x30f0
movq 0x7b24(%rip), %rcx      # 0xf250
leaq 0x2c89(%rip), %rdi      # 0xa3bc
leaq 0x2c87(%rip), %rsi      # 0xa3c1
leaq 0x2c83(%rip), %rdx      # 0xa3c4
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x56d6
movq %rax, %r14
testq %rax, %rax
je 0x778f
cmpw $0x0, 0x104(%r14)
je 0x778f
movq 0x28(%rbx), %rax
cmpq 0x7556(%rip), %rax      # 0xecc8
jne 0x777e
movq %r14, %rdi
callq 0x6809
jmp 0x778f
cmpq 0x754b(%rip), %rax      # 0xecd0
jne 0x778f
movq %r14, %rdx
callq 0x4ca8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5dae
leaq 0x2c2d(%rip), %rdi      # 0xa3d2
xorl %eax, %eax
callq 0x30f0
xorl %edi, %edi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x56d6
movq %rax, %r14
movq 0x20(%rbx), %rax
cmpq 0x79d7(%rip), %rax      # 0xf1a8
jne 0x77ec
movq 0x28(%rbx), %rax
cmpq 0x7592(%rip), %rax      # 0xed70
jne 0x77ec
callq 0x6e79
callq 0x681b
jmp 0x7839
testq %r14, %r14
je 0x7839
cmpw $0x0, 0x102(%r14)
je 0x7839
cmpw $0x0, 0x104(%r14)
je 0x7839
movq %r14, %rdi
callq 0x5f9b
movq 0x28(%rbx), %rax
cmpq 0x7556(%rip), %rax      # 0xed70
je 0x7825
cmpq 0x74cd(%rip), %rax      # 0xecf0
jne 0x7839
movl 0x118(%r14), %edi
movswl 0x100(%r14), %esi
callq 0x6c0c
movq %r14, %rdi
callq 0x5dae
pushq $0x1c
popq %rbp
movq 0x7365(%rip), %rdi      # 0xebb0
movq 0x20(%rbx), %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x30d0
testl %eax, %eax
jne 0x7844
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x56d6
movq %rax, %rbx
testq %rax, %rax
je 0x78be
cmpw $0x0, 0x102(%rbx)
je 0x78be
cmpw $0x0, 0x104(%rbx)
je 0x78be
movq %rbx, %rdi
callq 0x5f9b
movq %rbx, %rdi
popq %rbx
jmp 0x5dae
// File: /workspace/github_c_makefile_star2_O2/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 0x790c
pushq %rbx
movq %rdx, %rbx
movswl 0x100(%rdx), %edx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x60e9
movq %rbx, %rdi
callq 0x6580
movq 0x118(%rbx), %rdi
movw %di, 0x7950(%rip)       # 0xf248
movswl 0x100(%rbx), %esi
movw %si, 0x7944(%rip)       # 0xf24a
popq %rbx
jmp 0x6eb3
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5607
movl 0x7457(%rip), %eax      # 0xeda0
xorl %r15d, %r15d
testw %ax, %ax
cmovlel %r15d, %eax
movzwl %ax, %r12d
leaq 0x7442(%rip), %r13      # 0xeda0
cmpq %r15, %r12
je 0x79a1
movq 0x8(%r13,%r15,8), %r14
testq %r14, %r14
je 0x799c
cmpw $0x0, 0x102(%r14)
je 0x799c
cmpw $0x0, 0x104(%r14)
je 0x799c
movq 0x128(%r14), %rdi
testq %rdi, %rdi
je 0x799c
movq %rbx, %rsi
callq 0x3060
testq %rax, %rax
jne 0x79b2
incq %r15
jmp 0x795e
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4ef3
movq %r14, %rdi
callq 0x6809
movl 0x118(%r14), %edi
movswl 0x100(%r14), %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6eb3
// File: /workspace/github_c_makefile_star2_O2/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 0x7a29
pushq %rbx
movq %rdx, %rbx
movswl 0x7863(%rip), %edi      # 0xf24a
callq 0x4f4a
movw %ax, 0x100(%rbx)
movl 0x118(%rbx), %esi
movswl %ax, %edx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x60e9
movq %rbx, %rdi
callq 0x6580
movswl 0x100(%rbx), %esi
movw %si, 0x782d(%rip)       # 0xf24a
movl 0x118(%rbx), %edi
popq %rbx
jmp 0x6eb3
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movswl 0x7816(%rip), %edi      # 0xf24a
callq 0x4f4a
movl %eax, %ebx
movswl 0x7806(%rip), %edi      # 0xf248
movl %eax, %esi
xorl %edx, %edx
callq 0x6fe0
testq %rax, %rax
jne 0x7a6a
pushq $0x1
popq %rbp
cmpl $0x4, %ebp
je 0x7a6a
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x6fe0
incl %ebp
testq %rax, %rax
je 0x7a53
movswl 0x77d7(%rip), %edi      # 0xf248
movswl 0x77d2(%rip), %esi      # 0xf24a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6eb3
// File: /workspace/github_c_makefile_star2_O2/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 0x934b
movq %rsi, %rbx
movzbl 0x21(%rsi), %edx
movl %edx, %eax
xorb $0x2a, %al
movl %ecx, %esi
xorb $0x8, %sil
orb %al, %sil
je 0x934b
cmpl $0x21, %edx
je 0x9346
cmpl $0x1c, %edx
je 0x9346
cmpl $0xc, %edx
jne 0x931a
cmpl $0x2, %ecx
je 0x934b
cmpl $0x8, %ecx
je 0x934b
movq 0x4cc7(%rip), %rax      # 0xdfe8
movq (%rax), %rdi
leaq 0x180a(%rip), %rsi      # 0xab35
xorl %eax, %eax
callq 0x3660
movq 0x5f27(%rip), %rax      # 0xf260
movq 0x5870(%rip), %rdi      # 0xebb0
movq %rbx, %rsi
popq %rbx
jmpq *%rax
cmpl $0xa, %ecx
jne 0x931a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: mul7
__inline__ static void mul2(__m128i in, __m128i *out) {
	const __m128i shuf = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
	const __m128i mask = _mm_set_epi32(135, 1, 1, 1);
	block intmp = _mm_shuffle_epi8(in, shuf);
	block tmp = _mm_srai_epi32(intmp, 31);
	tmp = _mm_and_si128(tmp, mask);
	tmp = _mm_shuffle_epi32(tmp, _MM_SHUFFLE(2, 1, 0, 3));
	*out = _mm_slli_epi32(intmp, 1);
	*out = _mm_xor_si128(*out, tmp);
	*out = _mm_shuffle_epi8(*out, shuf);
}

// Assembly:
vmovdqa 0x1445(%rip), %xmm1     # 0x3000
vpshufb %xmm1, %xmm0, %xmm2
vpshufd $0x93, %xmm2, %xmm3     # xmm3 = xmm2[3,0,1,2]
vpshufd $0x93, 0x14a2(%rip), %xmm4 # xmm4 = mem[3,0,1,2]
vpsrad $0x1f, %xmm3, %xmm3
vpaddd %xmm2, %xmm2, %xmm2
vpternlogd $0x6c, %xmm4, %xmm2, %xmm3
vpshufd $0x93, %xmm2, %xmm2     # xmm2 = xmm2[3,0,1,2]
vpsrad $0x1f, %xmm2, %xmm2
vpand %xmm4, %xmm2, %xmm2
vpaddd %xmm3, %xmm3, %xmm4
vpternlogd $0x96, %xmm2, %xmm3, %xmm4
vpshufb %xmm1, %xmm4, %xmm1
vpxor %xmm0, %xmm1, %xmm0
vmovdqa %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: AFuncS
__m128i AFuncS(
	const uint8 *header,
	uint32 h_len)
{
	uint32 i;
	uint32 m, last;
	block chain = _mm_setzero_si128(), tmp, mask;
	const __m128i *hdp = (__m128i*)header;

	last = h_len % BLOCK;
	if (last == 0) last = BLOCK;
	m = (h_len - last) / BLOCK; //header = m blocks + last bytes

	for (i = 0; i < m; i++){
		chain = _mm_xor_si128(chain, hdp[i]);
		AES_encrypt(chain, &chain, encrypt_key);
	}
	hdp += m;
	/* last block */
	ozp(last, (uint8*)&hdp[0], &tmp);
	chain = _mm_xor_si128(tmp, chain);
	if (last != BLOCK){
		mul2(Q, &mask);
	}
	else{
		mul4(Q, &mask);
	}
	chain = _mm_xor_si128(chain, mask);
	AES_encrypt(chain, &chain, encrypt_key);
	return chain; //TA
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r14d
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r15
vmovaps %xmm0, (%r15)
movl %esi, %eax
andl $0xf, %eax
pushq $0x10
popq %r12
movl %eax, 0x10(%rsp)
cmovnel %eax, %r12d
subl %r12d, %r14d
movl %r14d, %r13d
shrl $0x4, %r13d
andl $-0x10, %r14d
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x26e9
vmovaps (%rbx,%rbp), %xmm0
vxorps (%rsp), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0x11b1
addq $0x10, %rbp
jmp 0x26c7
shll $0x4, %r13d
addq %r13, %rbx
movl %r12d, %r14d
pushq $0x11
popq %rdx
subq %r14, %rdx
leaq (%rsp,%r14), %r15
addq $0x20, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x1030
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10b0
movb $-0x80, (%r15)
vmovdqa (%r12), %xmm3
vmovdqa (%rsp), %xmm4
cmpl $0x0, 0x10(%rsp)
je 0x276c
movq 0x48a5(%rip), %rax      # 0x6fe0
vmovdqa (%rax), %xmm0
vmovdqa 0x8b9(%rip), %xmm1      # 0x3000
vpshufb %xmm1, %xmm0, %xmm0
vpshufd $0x93, %xmm0, %xmm2     # xmm2 = xmm0[3,0,1,2]
vpsrad $0x1f, %xmm2, %xmm2
vpaddd %xmm0, %xmm0, %xmm0
vpternlogd $0x78, 0x8ab(%rip), %xmm2, %xmm0 # 0x3010
vpshufb %xmm1, %xmm0, %xmm0
jmp 0x27a0
movq 0x486d(%rip), %rax      # 0x6fe0
vmovaps (%rax), %xmm0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
vmovdqa %xmm3, 0x10(%rsp)
vmovdqa %xmm4, 0x40(%rsp)
callq 0x27c9
vmovdqa 0x40(%rsp), %xmm4
vmovdqa 0x10(%rsp), %xmm3
vmovdqa (%rbx), %xmm0
vpternlogq $0x96, %xmm3, %xmm4, %xmm0
movq %rsp, %rbx
vmovdqa %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x11b1
vmovaps (%rbx), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x1040
testl %ebp, %ebp
je 0x2848
movq %r13, %rdi
movl %ebp, %esi
callq 0x1090
jmp 0x284c
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
pushq $0xc
popq %rsi
pushq $0x10
popq %r8
movq 0x58(%rsp), %rdi
movq %r12, %rdx
movl %ebx, %ecx
movq %r15, %r9
callq 0x1060
vxorps (%rsp), %xmm0, %xmm0
vmovups %xmm0, (%r15,%rbx)
addq $0x10, %rbx
movq %rbx, (%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl 0x60(%rsp), %r13d
leaq -0x10(%r8), %rax
movq %rax, (%rsi)
callq 0x1040
testl %r13d, %r13d
je 0x28cd
movq %rbp, %rdi
movl %r13d, %esi
callq 0x1090
jmp 0x28d1
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
addl $-0x10, %r15d
pushq $0xc
popq %rsi
pushq $0x10
popq %r8
movq 0x68(%rsp), %rdi
movq %rbx, %rdx
movl %r15d, %ecx
movq %r12, %r9
callq 0x1070
vxorps (%rsp), %xmm0, %xmm0
vmovaps %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 $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1220
movq 0x8(%rbx), %r14
leaq 0xe6d(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x11f6
leaq 0xe5f(%rip), %rsi       # 0x2009
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x11fd
leaq 0xe52(%rip), %rsi       # 0x200f
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x1204
leaq 0xe48(%rip), %rsi       # 0x2018
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
je 0x1219
leaq 0xe3c(%rip), %rsi       # 0x201f
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
jne 0x1220
movl $0xd000fce2, %edi       # imm = 0xD000FCE2
jmp 0x124b
movl $0xcdef0123, %edi       # imm = 0xCDEF0123
jmp 0x124b
movl $0x45584543, %edi       # imm = 0x45584543
jmp 0x124b
callq 0x1070
testl %eax, %eax
jle 0x1246
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1050
movl $0x1234567, %edi        # imm = 0x1234567
jmp 0x124b
movq 0x2dd1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xdf3(%rip), %rsi       # 0x2027
xorl %eax, %eax
callq 0x1040
pushq $0x40
popq %rax
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebp, %ebp
movl $0x0, %ebx
cmpl $0x2, %edi
jl 0x11d0
movq %rsi, %r14
movq 0x8(%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1080
movl %eax, %ebx
testl %eax, %eax
js 0x126b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1294
leaq 0x2e8c(%rip), %r15      # 0x4070
pushq $0x40
popq %r13
movl %ebp, %r12d
leaq (%r15,%r12), %rsi
movl %r13d, %edx
subl %ebp, %edx
movl %ebx, %edi
callq 0x1050
testl %eax, %eax
jle 0x121a
addl %eax, %r12d
movl %r12d, %ebp
cmpl $0x40, %r12d
jl 0x11e8
movq %r14, %rdi
movq %r15, %rsi
callq 0x12ab
xorl %ebp, %ebp
jmp 0x11e8
leaq 0x2e4f(%rip), %rsi      # 0x4070
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x1432
leaq 0xde8(%rip), %rbx       # 0x201d
xorl %r14d, %r14d
cmpq $0x5, %r14
je 0x1252
movl 0x8(%rsp,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
incq %r14
jmp 0x1238
pushq $0xa
popq %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d86(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0xd81(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1060
pushq $0x1
popq %rdi
callq 0x1090
nop
// File: /workspace/github_c_makefile_star2_O2/ls4154[P]hash-c/sha1.c
// Function: sha1_iterate
static void _sha1_iterate(struct sha1_ctx *ctx, byte_t *chunk)
{
	word_t w[80];

	for (int i = 0; i < 16; ++i) {
		w[i] = 0;
		for (int j = 0; j < 4; ++j)
			w[i] |= (word_t)*(chunk + 4 * i + j) << 8 * (3 - j);
	}

#ifdef SHA0
	for (int i = 16; i < 80; ++i)
		w[i] = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
#else
	for (int i = 16; i < 80; ++i)
		w[i] = ROL(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
#endif

	word_t a = ctx->h[0];
	word_t b = ctx->h[1];
	word_t c = ctx->h[2];
	word_t d = ctx->h[3];
	word_t e = ctx->h[4];

	for (int i = 0; i < 80; ++i) {
		word_t tmp;
		word_t k;

		switch (i / 20) {
		case 0:
			tmp = (b & c) | ((~b) & d);
			k = 0x5a827999;
			break;
		case 1:
			tmp = b ^ c ^ d;
			k = 0x6ed9eba1;
			break;
		case 2:
			tmp = (b & c) | (b & d) | (c & d);
			k = 0x8f1bbcdc;
			break;
		default :
			tmp = b ^ c ^ d;
			k = 0xca62c1d6;
		}
		tmp += ROL(a, 5) + e + k + w[i];
		e = d;
		d = c;
		c = ROL(b, 30);
		b = a;
		a = tmp;
	}

	ctx->h[0] += a;
	ctx->h[1] += b;
	ctx->h[2] += c;
	ctx->h[3] += d;
	ctx->h[4] += e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
xorl %eax, %eax
movl $0x18, %edx
cmpq $0x10, %rax
je 0x1308
xorl %r8d, %r8d
movl %edx, %ecx
xorl %r9d, %r9d
cmpq $0x4, %r8
je 0x12fa
movzbl (%rsi,%r8), %r10d
shll %cl, %r10d
orl %r10d, %r9d
incq %r8
addl $-0x8, %ecx
jmp 0x12e1
movl %r9d, -0x70(%rsp,%rax,4)
incq %rax
addq $0x4, %rsi
jmp 0x12d3
movabsq $0x10, %rax
cmpq $0x50, %rax
je 0x133c
movl -0x90(%rsp,%rax,4), %ecx
xorl -0x7c(%rsp,%rax,4), %ecx
xorl -0xa8(%rsp,%rax,4), %ecx
xorl -0xb0(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
jmp 0x1312
movl (%rdi), %r9d
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %r10d
xorl %ebx, %ebx
movb $0x14, %r15b
movl %r9d, %eax
movl %ecx, %r8d
movl %esi, %ebp
movl %edx, %r11d
movl %r10d, -0x74(%rsp)
movl %r10d, %r14d
movl %r11d, %r10d
movl %ebp, %r11d
movl %r8d, %ebp
movl %eax, %r8d
cmpq $0x50, %rbx
je 0x13fe
movzbl %bl, %eax
divb %r15b
cmpb $0x2, %al
je 0x13b3
movzbl %al, %eax
cmpl $0x1, %eax
je 0x13a3
testl %eax, %eax
jne 0x13cd
movl %r11d, %eax
xorl %r10d, %eax
andl %ebp, %eax
xorl %r10d, %eax
movl $0x5a827999, %r13d      # imm = 0x5A827999
jmp 0x13db
movl %r11d, %eax
xorl %ebp, %eax
xorl %r10d, %eax
movl $0x6ed9eba1, %r13d      # imm = 0x6ED9EBA1
jmp 0x13db
movl %r10d, %r13d
orl %r11d, %r13d
andl %ebp, %r13d
movl %r10d, %eax
andl %r11d, %eax
orl %r13d, %eax
movl $0x8f1bbcdc, %r13d      # imm = 0x8F1BBCDC
jmp 0x13db
movl %r11d, %eax
xorl %ebp, %eax
xorl %r10d, %eax
movl $0xca62c1d6, %r13d      # imm = 0xCA62C1D6
movl %r8d, %r12d
roll $0x5, %r12d
addl %r12d, %r14d
addl %eax, %r14d
addl %r13d, %r14d
addl -0x70(%rsp,%rbx,4), %r14d
roll $0x1e, %ebp
incq %rbx
movl %r14d, %eax
jmp 0x1361
addl %r9d, %r8d
movl %r8d, (%rdi)
addl %ecx, %ebp
movl %ebp, 0x4(%rdi)
addl %esi, %r11d
movl %r11d, 0x8(%rdi)
addl %edx, %r10d
movl %r10d, 0xc(%rdi)
addl -0x74(%rsp), %r14d
movl %r14d, 0x10(%rdi)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x38, %r14
jb 0x1495
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12bb
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
shlq $0x3, %r15
pushq $0x7
popq %rax
pushq $0x38
popq %rcx
leaq 0x38(%rsp), %rdx
testl %eax, %eax
js 0x14bb
movq %r15, %rsi
shrq %cl, %rsi
movb %sil, (%rdx)
incq %rdx
decl %eax
addl $-0x8, %ecx
jmp 0x14a4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12bb
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb4b(%rip), %xmm0      # 0x2030
movups %xmm0, (%rdi)
movl $0xc3d2e1f0, 0x10(%rdi) # imm = 0xC3D2E1F0
andq $0x0, 0x18(%rdi)
cmpq $0x40, %rbx
jb 0x150f
movq %r15, %rdi
movq %r14, %rsi
callq 0x12ab
addq $0x40, %r14
addq $-0x40, %rbx
jmp 0x14f4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1432
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
callq 0x5100
movl %eax, %ebx
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
pushq $0x4
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
callq 0x5100
andl $0x0, (%r14)
callq 0x5280
movl %eax, %r15d
cmpl $0x1b, %eax
jne 0x56d1
callq 0x5280
cmpl $0x5b, %eax
jne 0x56bc
movl $0x1, (%r14)
callq 0x5280
movl %eax, %r15d
jmp 0x56d1
movq 0x2990d(%rip), %rcx     # 0x2efd0
movq (%rcx), %rsi
movl %eax, %edi
callq 0x5360
pushq $0x1b
popq %r15
pushq $0x4
popq %rsi
xorl %edi, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x5100
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: sleephires
void sleephires(double sec) {
  long s = (long)floor(sec);
  long n = (long)floor((sec - s) * 1e9);
  struct timespec delay = { .tv_sec = s, .tv_nsec = n };
  nanosleep(&delay, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x10(%rbp)
callq 0x5450
cvttsd2si %xmm0, %rbx
cvtsi2sd %rbx, %xmm0
movsd -0x10(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x198f5(%rip), %xmm1    # 0x1f010
movapd %xmm1, %xmm0
callq 0x5450
cvttsd2si %xmm0, %rax
leaq -0x20(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x5190
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: start
void start() {
  // Terminal setup.
  system("tput setab 0");    // Use a black background.
  system("tput clear");      // Clear the screen.
  system("tput civis");      // Hide the cursor.
  system("stty raw -echo");  // Improve access to keypresses.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x198d3(%rip), %rdi     # 0x1f020
callq 0x5150
leaq 0x198d4(%rip), %rdi     # 0x1f02d
callq 0x5150
leaq 0x198d3(%rip), %rdi     # 0x1f038
callq 0x5150
leaq 0x198d2(%rip), %rdi     # 0x1f043
popq %rbp
jmp 0x5150
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: done
void done() {

  // Put the terminal back into a decent state.
  system("stty cooked echo");  // Undo init call to "stty raw".
  system("tput reset");        // Reset colors and clear screen.

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x198d0(%rip), %rdi     # 0x1f052
callq 0x5150
leaq 0x198d5(%rip), %rdi     # 0x1f063
callq 0x5150
xorl %edi, %edi
callq 0x5470
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: push_keypress
void push_keypress(lua_State *L, int key, int is_end_of_seq) {
  if (is_end_of_seq && 65 <= key && key <= 68) {
    // up, down, right, left = 65, 66, 67, 68
    static const char *arrow_names[] = {"up", "down",
                                        "right", "left"};
    lua_pushstring(L, arrow_names[key - 65]);
  } else {
    lua_pushnumber(L, key);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
sete %cl
leal -0x41(%rsi), %eax
cmpl $0x4, %eax
setae %dl
orb %cl, %dl
jne 0x57c6
movl %eax, %eax
leaq 0x1991f(%rip), %rcx     # 0x1f0d8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
popq %rbp
jmp 0x61d0
cvtsi2sd %esi, %xmm0
popq %rbp
jmp 0x6146