LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x74a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb220
movq -0x10(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb220
movw 0x9117(%rip), %cx       # 0x1423a
movq -0x10(%rbp), %rax
movw %cx, 0x100(%rax)
movq -0x10(%rbp), %rax
movswq 0x100(%rax), %rcx
leaq 0x8a6f(%rip), %rax      # 0x13bb0
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl 0x90ae(%rip), %eax      # 0x14200
movq -0x10(%rbp), %rcx
movswl 0x100(%rcx), %ecx
cmpl %ecx, %eax
jbe 0xb17d
movq 0x90a0(%rip), %rax      # 0x14208
movq -0x10(%rbp), %rcx
movswq 0x100(%rcx), %rcx
movswl (%rax,%rcx,8), %eax
movl %eax, -0x24(%rbp)
jmp 0xb187
movl $0x5, %eax
movl %eax, -0x24(%rbp)
jmp 0xb187
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jne 0xb19d
movswl 0x909e(%rip), %eax      # 0x14238
movl %eax, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jne 0xb1fe
movl $0x1, -0x1c(%rbp)
movl $0x3, -0x20(%rbp)
cmpl $0x1, -0x20(%rbp)
jl 0xb1fc
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movswl 0xc(%rcx,%rdx,8), %ecx
cmpl %ecx, %eax
jg 0xb1ef
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movswl 0xe(%rcx,%rdx,8), %ecx
cmpl %ecx, %eax
jg 0xb1ef
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xb1fc
jmp 0xb1f1
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb1b1
jmp 0xb1fe
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movswl 0x100(%rax), %edx
xorl %ecx, %ecx
callq 0x8c50
movq -0x10(%rbp), %rdi
callq 0x8a30
cmpq $0x0, -0x10(%rbp)
je 0xb23a
movq 0x8972(%rip), %rdi      # 0x13ba0
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3350
movq -0x10(%rbp), %rdi
callq 0x86e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x74a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb2bf
movq -0x18(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb2bf
movq -0x18(%rbp), %rdi
callq 0x97c0
movq -0x18(%rbp), %rdi
callq 0x8a30
movq -0x18(%rbp), %rdi
callq 0x9a40
movq -0x10(%rbp), %rdi
callq 0x86e0
callq 0x8720
callq 0xa700
callq 0x9bb0
movq -0x18(%rbp), %rdi
callq 0x86e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x88bd(%rip), %rax      # 0x13ba8
jne 0xb347
movswl 0x8f44(%rip), %edi      # 0x14238
movswl 0x8f3f(%rip), %esi      # 0x1423a
movq 0x88a6(%rip), %rdx      # 0x13ba8
callq 0xaad0
cmpq $0x0, %rax
jne 0xb347
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jg 0xb345
movl -0xc(%rbp), %edi
movswl 0x8f16(%rip), %esi      # 0x1423a
movq 0x887d(%rip), %rdx      # 0x13ba8
callq 0xaad0
cmpq $0x0, %rax
je 0xb338
jmp 0xb345
jmp 0xb33a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb314
jmp 0xb347
callq 0x8720
callq 0xa700
callq 0x9bb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8815(%rip)      # 0x13d88
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x74a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb5a9
movq -0x28(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb5a9
movq -0x28(%rbp), %rdi
callq 0x9b80
jmp 0xb65f
cmpq $0x0, 0x8c27(%rip)      # 0x141d8
je 0xb65d
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x8197(%rip), %ecx      # 0x13760
movb %al, -0x29(%rbp)
jge 0xb5ee
movslq -0xc(%rbp), %rcx
leaq 0x85d7(%rip), %rax      # 0x13bb0
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb5f7
jmp 0xb65b
movl $0x1, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jg 0xb64b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x28(%rax,%rcx,8)
je 0xb63e
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x28(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0xb63e
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xaad0
jmp 0xb640
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb5fe
jmp 0xb64d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb5be
jmp 0xb65d
jmp 0xb65f
movq -0x28(%rbp), %rdi
callq 0x86e0
movq 0x8531(%rip), %rdi      # 0x13ba0
movq 0x8712(%rip), %rdx      # 0x13d88
movl $0x2, %esi
callq 0x3340
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x85e5(%rip), %rax      # 0x13c98
jne 0xb6ca
leaq 0x3c12(%rip), %rdi      # 0xf2ce
movb $0x0, %al
callq 0x30f0
xorl %edi, %edi
callq 0x3100
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x85c7(%rip), %rax      # 0x13ca0
jne 0xb711
leaq 0x3bf2(%rip), %rdi      # 0xf2d4
movb $0x0, %al
callq 0x30f0
movq 0x8b50(%rip), %rcx      # 0x14240
leaq 0x3bbd(%rip), %rdi      # 0xf2b4
leaq 0x3bbb(%rip), %rsi      # 0xf2b9
leaq 0x3bb7(%rip), %rdx      # 0xf2bc
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x3190
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x74a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb779
movq -0x18(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb779
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x8570(%rip), %rax      # 0x13cb8
jne 0xb755
movq -0x18(%rbp), %rdi
callq 0x9b80
jmp 0xb777
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x855c(%rip), %rax      # 0x13cc0
jne 0xb775
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x5fa0
jmp 0xb777
jmp 0xb779
movq -0x18(%rbp), %rdi
callq 0x86e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x74a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x89d4(%rip), %rax      # 0x14198
jne 0xb7e3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x858b(%rip), %rax      # 0x13d60
jne 0xb7e3
callq 0xa700
callq 0x9bb0
jmp 0xb856
cmpq $0x0, -0x18(%rbp)
je 0xb854
movq -0x18(%rbp), %rax
movswl 0x102(%rax), %eax
cmpl $0x0, %eax
je 0xb854
movq -0x18(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb854
movq -0x18(%rbp), %rdi
callq 0x8a30
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x853e(%rip), %rax      # 0x13d60
je 0xb835
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0x84ad(%rip), %rax      # 0x13ce0
jne 0xb852
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movswl 0x100(%rax), %esi
callq 0xa280
jmp 0xb854
jmp 0xb856
movq -0x18(%rbp), %rdi
callq 0x86e0
movq 0x833a(%rip), %rdi      # 0x13ba0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rcx
movl $0x1c, %edx
callq 0x30d0
cmpl $0x0, %eax
je 0xb883
jmp 0xb85f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x74a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb91d
movq -0x10(%rbp), %rax
movswl 0x102(%rax), %eax
cmpl $0x0, %eax
je 0xb91d
movq -0x10(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xb91d
movq -0x10(%rbp), %rdi
callq 0x8a30
movq -0x10(%rbp), %rdi
callq 0x86e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb94c
jmp 0xb9b2
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movswl 0x100(%rax), %edx
movl $0x1, %ecx
callq 0x8c50
movq -0x18(%rbp), %rdi
callq 0x97c0
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movw %ax, 0x88b5(%rip)       # 0x14238
movq -0x18(%rbp), %rax
movw 0x100(%rax), %ax
movw %ax, 0x88a5(%rip)       # 0x1423a
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movswl 0x100(%rax), %esi
callq 0xa790
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x7380
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movswl 0x835f(%rip), %ecx      # 0x13d90
cmpl %ecx, %eax
jge 0xbad5
movslq -0x1c(%rbp), %rcx
leaq 0x834c(%rip), %rax      # 0x13d90
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbac5
movq -0x28(%rbp), %rax
movswl 0x102(%rax), %eax
cmpl $0x0, %eax
je 0xbac3
movq -0x28(%rbp), %rax
movswl 0x104(%rax), %eax
cmpl $0x0, %eax
je 0xbac3
movq -0x28(%rbp), %rax
cmpq $0x0, 0x128(%rax)
je 0xbac3
movq -0x28(%rbp), %rax
movq 0x128(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3060
cmpq $0x0, %rax
je 0xbac3
movq -0x28(%rbp), %rdi
callq 0x9b80
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movl %eax, %edi
movq -0x28(%rbp), %rax
movswl 0x100(%rax), %esi
callq 0xa790
jmp 0xbade
jmp 0xbac5
jmp 0xbac7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xba27
movq -0x30(%rbp), %rdi
callq 0x63d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbb0c
jmp 0xbb87
movswl 0x8727(%rip), %edi      # 0x1423a
movl -0xc(%rbp), %esi
callq 0x6450
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x100(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
movswl 0x100(%rax), %edx
movl $0x1, %ecx
callq 0x8c50
movq -0x18(%rbp), %rdi
callq 0x97c0
movq -0x18(%rbp), %rax
movw 0x100(%rax), %ax
movw %ax, 0x86d0(%rip)       # 0x1423a
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movswl 0x100(%rax), %esi
callq 0xa790
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movswl 0x8690(%rip), %edi      # 0x1423a
movl -0xc(%rbp), %esi
callq 0x6450
movl %eax, -0x20(%rbp)
movswl 0x867c(%rip), %edi      # 0x14238
movl -0x20(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xaad0
cmpq $0x0, %rax
jne 0xbc01
movl $0x1, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jg 0xbbff
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xaad0
cmpq $0x0, %rax
je 0xbbf2
jmp 0xbbff
jmp 0xbbf4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbbd5
jmp 0xbc01
movswl 0x8630(%rip), %edi      # 0x14238
movswl 0x862b(%rip), %esi      # 0x1423a
callq 0xa790
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x3, %eax
je 0xe5b3
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2a, %eax
jne 0xe54b
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
je 0xe5b3
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0xc, %eax
jne 0xe565
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x8, %eax
je 0xe5b3
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0xc, %eax
jne 0xe57f
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x2, %eax
je 0xe5b3
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x1c, %eax
jne 0xe599
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
je 0xe5b3
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x21, %eax
jne 0xe5bc
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xa, %eax
jne 0xe5bc
movl $0x0, -0x4(%rbp)
jmp 0xe5fb
movq 0x4a25(%rip), %rax      # 0x12fe8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %ecx
leaq 0x145a(%rip), %rsi      # 0xfa37
movb $0x0, %al
callq 0x3650
movq 0x5c65(%rip), %rax      # 0x14250
movq 0x55ae(%rip), %rdi      # 0x13ba0
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: xorp
__inline__ static void xorp(uint32 length, const __m128i *x, const uint8 *y, uint8 *z){
	__m128i tmp = _mm_setzero_si128();
	memcpy((uint8*)&tmp, y, length);
	tmp = _mm_xor_si128(*x, tmp);
	memcpy(z, (uint8*)&tmp, length);
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
vmovdqa %xmm0, (%rsp)
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %eax
movl %eax, %edx
movq %rsp, %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
vmovdqa (%rax), %xmm1
vmovdqa (%rsp), %xmm0
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vpxor 0x40(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %edx
movq %rsp, %rsi
callq 0x10b0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: ozp
__inline__ static  void ozp(uint32 length, const uint8 *in, __m128i *out){
	ALIGN(16)uint8 tmp[BLOCK + 1] = { 0 };
	memcpy(tmp, in, length);
	tmp[length] = 0x80;
	*out = _mm_load_si128((__m128i*)tmp);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0x1030
movq %rsp, %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rsp), %eax
movl %eax, %edx
callq 0x10b0
movl 0x2c(%rsp), %eax
movb $-0x80, (%rsp,%rax)
movq %rsp, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes256otrpv3/ni_p8m1/encrypt.c
// Function: mul7
__inline__ static void mul7(__m128i in, __m128i *out){
	__m128i tmp;
	mul2(in, &tmp);
	*out = _mm_xor_si128(in, tmp);
	mul2(tmp, &tmp);
	*out = _mm_xor_si128(*out, tmp);
}

// Assembly:
subq $0x78, %rsp
vmovdqa %xmm0, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
vmovdqa 0x20(%rsp), %xmm0
movq %rsp, %rdi
callq 0x4df0
vmovdqa 0x20(%rsp), %xmm1
vmovdqa (%rsp), %xmm0
vmovdqa %xmm1, 0x60(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vpxor 0x50(%rsp), %xmm0, %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, (%rax)
vmovdqa (%rsp), %xmm0
movq %rsp, %rdi
callq 0x4df0
movq 0x18(%rsp), %rax
vmovdqa (%rax), %xmm1
vmovdqa (%rsp), %xmm0
vmovdqa %xmm1, 0x40(%rsp)
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vpxor 0x30(%rsp), %xmm0, %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, (%rax)
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vmovdqa %xmm0, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x54(%rsp), %eax
andl $0xf, %eax
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jne 0x6afa
movl $0x10, 0x48(%rsp)
movl 0x54(%rsp), %eax
subl 0x48(%rsp), %eax
shrl $0x4, %eax
movl %eax, 0x4c(%rsp)
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x6b83
vmovdqa 0x30(%rsp), %xmm1
movq 0x8(%rsp), %rax
movl 0x50(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xc0(%rsp)
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0xc0(%rsp), %xmm0
vpxor 0xb0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
movq 0x547f(%rip), %rsi      # 0xbff0
callq 0x11e0
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x6b11
movl 0x4c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x48(%rsp), %edi
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5160
vmovdqa 0x20(%rsp), %xmm1
vmovdqa 0x30(%rsp), %xmm0
vmovdqa %xmm1, 0xa0(%rsp)
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0xa0(%rsp), %xmm0
vpxor 0x90(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
cmpl $0x10, 0x48(%rsp)
je 0x6c01
movq 0x53ef(%rip), %rax      # 0xbfe0
vmovdqa (%rax), %xmm0
leaq 0x10(%rsp), %rdi
callq 0x4df0
jmp 0x6c16
movq 0x53d8(%rip), %rax      # 0xbfe0
vmovdqa (%rax), %xmm0
leaq 0x10(%rsp), %rdi
callq 0x6c70
vmovdqa 0x30(%rsp), %xmm1
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm1, 0x80(%rsp)
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x80(%rsp), %xmm0
vpxor 0x70(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
movq 0x5398(%rip), %rsi      # 0xbff0
callq 0x11e0
vmovdqa 0x30(%rsp), %xmm0
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vmovdqa %xmm0, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x1040
movq 0x20(%rsp), %rax
cmpl $0x0, %eax
jbe 0x70d1
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
callq 0x1090
vmovdqa %xmm0, 0x10(%rsp)
movq 0x98(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rax
movl %eax, %ecx
movq 0x48(%rsp), %r9
movl $0xc, %esi
movl $0x10, %r8d
callq 0x1060
vmovdqa %xmm0, (%rsp)
vmovdqa (%rsp), %xmm1
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm1, 0x70(%rsp)
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vpxor 0x60(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq 0x8(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x30(%rsp), %rcx
addq $0x10, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rax
movq 0xb0(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vmovdqa %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rcx
subq $0x10, %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0xc0(%rsp), %rdi
callq 0x1040
movq 0xb0(%rsp), %rax
cmpl $0x0, %eax
jbe 0x71f8
movq 0x38(%rsp), %rdi
movq 0xb0(%rsp), %rax
movl %eax, %esi
callq 0x1090
vmovdqa %xmm0, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rax
movl %eax, %ecx
subl $0x10, %ecx
movq 0x60(%rsp), %r9
movl $0xc, %esi
movl $0x10, %r8d
callq 0x1070
vmovdqa %xmm0, (%rsp)
vmovdqa (%rsp), %xmm1
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm1, 0x90(%rsp)
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vpxor 0x80(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %rdx
movq (%rdx), %rdx
movl %edx, %edx
addq %rdx, %rcx
vmovdqu (%rcx), %xmm1
vmovdqu (%rax), %xmm0
vpxor %xmm1, %xmm0, %xmm0
vptest %xmm0, %xmm0
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x72ad
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
jmp 0x72b5
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x11c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe59(%rip), %rsi       # 0x2004
callq 0x1030
cmpl $0x0, %eax
jne 0x11c7
movl $0xcdef0123, %edi       # imm = 0xCDEF0123
callq 0x1060
movl %eax, -0x4(%rbp)
jmp 0x12cd
cmpl $0x2, -0x8(%rbp)
jne 0x11f8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe2d(%rip), %rsi       # 0x2009
callq 0x1030
cmpl $0x0, %eax
jne 0x11f8
movl $0x45584543, %edi       # imm = 0x45584543
callq 0x1060
movl %eax, -0x4(%rbp)
jmp 0x12cd
cmpl $0x2, -0x8(%rbp)
jne 0x1243
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe02(%rip), %rsi       # 0x200f
callq 0x1030
cmpl $0x0, %eax
jne 0x1243
callq 0x1070
cmpl $0x0, %eax
jle 0x122b
callq 0x1050
movl %eax, -0x14(%rbp)
jmp 0x1238
movl $0x4321fedc, %edi       # imm = 0x4321FEDC
callq 0x1060
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12cd
cmpl $0x2, -0x8(%rbp)
jne 0x1271
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xdc0(%rip), %rsi       # 0x2018
callq 0x1030
cmpl $0x0, %eax
jne 0x1271
movl $0x1234567, %edi        # imm = 0x1234567
callq 0x1060
movl %eax, -0x4(%rbp)
jmp 0x12cd
cmpl $0x2, -0x8(%rbp)
jne 0x129f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd99(%rip), %rsi       # 0x201f
callq 0x1030
cmpl $0x0, %eax
jne 0x129f
movl $0xd000fce2, %edi       # imm = 0xD000FCE2
callq 0x1060
movl %eax, -0x4(%rbp)
jmp 0x12cd
jmp 0x12a1
jmp 0x12a3
jmp 0x12a5
jmp 0x12a7
movq 0x2d4a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd68(%rip), %rsi       # 0x2027
movb $0x0, %al
callq 0x1040
movl $0x40, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x120d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1080
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x120d
movq 0x2e15(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xe08(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x1090
leaq -0x38(%rbp), %rdi
callq 0x12d0
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x14(%rbp), %edi
movslq -0x3c(%rbp), %rax
leaq 0x2e3e(%rip), %rsi      # 0x4070
addq %rax, %rsi
movl $0x40, %eax
subl -0x3c(%rbp), %eax
movslq %eax, %rdx
callq 0x1050
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
jle 0x1275
movl -0x40(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x40, -0x3c(%rbp)
jl 0x1273
leaq -0x38(%rbp), %rdi
leaq 0x2e09(%rip), %rsi      # 0x4070
callq 0x1320
movl $0x0, -0x3c(%rbp)
jmp 0x1224
movslq -0x3c(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x2dec(%rip), %rsi      # 0x4070
callq 0x1730
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
jge 0x12b7
movslq -0x44(%rbp), %rax
movl -0x38(%rbp,%rax,4), %esi
leaq 0xd78(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1030
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1290
leaq 0xd5d(%rip), %rdi       # 0x201b
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ls4154[P]hash-c/sha1.c
// Function: sha1_init
void sha1_init(struct sha1_ctx *ctx)
{
	ctx->h[0] = 0x67452301;
	ctx->h[1] = 0xefcdab89;
	ctx->h[2] = 0x98badcfe;
	ctx->h[3] = 0x10325476;
	ctx->h[4] = 0xc3d2e1f0;

	ctx->len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1040
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1070
movq -0x18(%rbp), %rax
movb $-0x80, -0x60(%rbp,%rax)
cmpq $0x38, -0x18(%rbp)
jb 0x17b2
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1360
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1040
leaq -0x60(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x68(%rbp)
movl $0x7, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jl 0x17ff
movq -0x20(%rbp), %rax
movl -0x6c(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x68(%rbp), %rax
movb %cl, (%rax)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movl -0x6c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x17c5
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1360
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12d0
cmpq $0x40, -0x18(%rbp)
jb 0x186b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1320
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x183d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1730
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x5110
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x5110
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
callq 0x5280
movl %eax, -0x10(%rbp)
cmpl $0x1b, -0x10(%rbp)
jne 0x56d0
callq 0x5280
movl %eax, -0x14(%rbp)
cmpl $0x5b, -0x14(%rbp)
jne 0x56be
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
callq 0x5280
movl %eax, -0x10(%rbp)
jmp 0x56d2
movl -0x14(%rbp), %edi
movq 0x3d908(%rip), %rax     # 0x42fd0
movq (%rax), %rsi
callq 0x5360
jmp 0x56d2
movl -0xc(%rbp), %edx
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x5110
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5440
cvttsd2si %xmm0, %rax
movq %rax, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x2e8e9(%rip), %xmm1    # 0x34010
mulsd %xmm1, %xmm0
callq 0x5440
cvttsd2si %xmm0, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x51a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x2e8b5(%rip), %rdi     # 0x34020
callq 0x5160
leaq 0x2e8b6(%rip), %rdi     # 0x3402d
callq 0x5160
leaq 0x2e8b5(%rip), %rdi     # 0x34038
callq 0x5160
leaq 0x2e8b4(%rip), %rdi     # 0x34043
callq 0x5160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x2e8a7(%rip), %rdi     # 0x34052
callq 0x5160
leaq 0x2e8ac(%rip), %rdi     # 0x34063
callq 0x5160
xorl %edi, %edi
callq 0x5460
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x5817
movl $0x41, %eax
cmpl -0xc(%rbp), %eax
jg 0x5817
cmpl $0x44, -0xc(%rbp)
jg 0x5817
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x41, %eax
movslq %eax, %rcx
leaq 0x3da94(%rip), %rax     # 0x432a0
movq (%rax,%rcx,8), %rsi
callq 0x6ce0
jmp 0x5825
movq -0x8(%rbp), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x6b90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch4/eatyguy8.c
// Function: push_state_table
void push_state_table(lua_State *L,
                      int key,
                      int is_end_of_seq) {

  lua_newtable(L);

    // stack = [.., {}]

  push_keypress(L, key, is_end_of_seq);

    // stack = [.., {}, key]

  lua_setfield(L, -2, "key");

    // stack = [.., {key = key}]

  lua_pushnumber(L, gettime());

    // stack = [.., {key = key}, clock]

  lua_setfield(L, -2, "clock");

    // stack = [.., {key = key, clock = clock}]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x75e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x57d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2e813(%rip), %rdx     # 0x34081
callq 0x7ae0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x5610
movq -0x18(%rbp), %rdi
callq 0x6b90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2e7ec(%rip), %rdx     # 0x34085
callq 0x7ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lapi.c
// Function: lua_checkstack
LUA_API int lua_checkstack (lua_State *L, int n) {
  int res;
  CallInfo *ci = L->ci;
  lua_lock(L);
  api_check(L, n >= 0, "negative 'n'");
  if (L->stack_last - L->top > n)  /* stack large enough? */
    res = 1;  /* yes; check is OK */
  else {  /* no; need to grow stack */
    int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;
    if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */
      res = 0;  /* no */
    else  /* try to grow stack */
      res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);
  }
  if (res && ci->top < L->top + n)
    ci->top = L->top + n;  /* adjust frame top */
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jle 0x5b44
movl $0x1, -0x10(%rbp)
jmp 0x5b9d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
addl $0x5, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5b79
movl $0x0, -0x10(%rbp)
jmp 0x5b9b
movq -0x8(%rbp), %rdi
leaq 0x6c(%rip), %rsi        # 0x5bf0
leaq -0xc(%rbp), %rdx
callq 0xac40
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x5b9d
cmpl $0x0, -0x10(%rbp)
je 0x5bde
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x5bde
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lapi.c
// Function: lua_xmove
LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
  int i;
  if (from == to) return;
  lua_lock(to);
  api_checknelems(from, n);
  api_check(from, G(from) == G(to), "moving among independent states");
  api_check(from, to->ci->top - to->top >= n, "stack overflow");
  from->top -= n;
  for (i = 0; i < n; i++) {
    setobj2s(to, to->top, from->top + i);
    to->top++;  /* stack already checked by previous 'api_check' */
  }
  lua_unlock(to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5c3b
jmp 0x5cb4
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5cb4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c60
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lapi.c
// Function: lua_atpanic
LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
  lua_CFunction old;
  lua_lock(L);
  old = G(L)->panic;
  G(L)->panic = panicf;
  lua_unlock(L);
  return old;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0xc0(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lapi.c
// Function: lua_settop
LUA_API void lua_settop (lua_State *L, int idx) {
  StkId func = L->ci->func;
  lua_lock(L);
  if (idx >= 0) {
    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
    while (L->top < (func + 1) + idx)
      setnilvalue(L->top++);
    L->top = (func + 1) + idx;
  }
  else {
    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
    L->top += idx+1;  /* 'subtract' index (index is negative) */
  }
  lua_unlock(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x5e3b
jmp 0x5de2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x5e1e
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, 0x8(%rax)
jmp 0x5de2
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5e57
movl -0xc(%rbp), %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax)