LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.h
// Function: cqs_newmetatable
static inline void cqs_newmetatable(lua_State *L, const char *name, const luaL_Reg *methods, const luaL_Reg *metamethods, int nup) {
	int i;

	luaL_newmetatable(L, name);
	for (i = 0; i < nup; i++) /* copy upvalues */
		lua_pushvalue(L, -nup - 1);
	luaL_setfuncs(L, metamethods, nup);

	lua_createtable(L, 0, cqs_regcount(methods));
	for (i = 0; i < nup; i++) /* copy upvalues */
		lua_pushvalue(L, -nup - 2);
	luaL_setfuncs(L, methods, nup);
	lua_setfield(L, -2, "__index");

	for (i = 0; i < nup; i++) /* remove the upvalues */
		lua_remove(L, -2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
callq 0x10180
testl %ebp, %ebp
jle 0x1103e
movl %ebp, %r12d
notl %r12d
movl %ebp, %r13d
movq %rbx, %rdi
movl %r12d, %esi
callq 0xf9c0
decl %r13d
jne 0x1102e
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x10240
leaq 0x8(%r14), %rax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpq $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0x11054
movq %rbx, %rdi
xorl %esi, %esi
callq 0x101e0
testl %ebp, %ebp
jle 0x110e1
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
subl %ebp, %r15d
movl %ebp, %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf9c0
decl %r12d
jne 0x1107a
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10240
leaq 0x24089(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
testl %ebp, %ebp
jle 0x110d2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xf0e0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
decl %ebp
jne 0x110af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10240
leaq 0x24032(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf530
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqs_sigmask
cqs_error_t cqs_sigmask(int how, const sigset_t *set, sigset_t *oset) {
	if (oset)
		sigemptyset(oset);

#if (defined _REENTRANT || defined _THREAD_SAFE) && _POSIX_THREADS > 0
	return pthread_sigmask(how, set, oset);
#else
	return sigprocmask(how, set, oset)? errno : 0;
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x11129
movq %rbx, %rdi
callq 0x10010
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xf350
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cstack_self
static struct cstack *cstack_self(lua_State *L) {
	static const int index = 47;
	struct cstack *CS;

	lua_rawgetp(L, LUA_REGISTRYINDEX, CQS_UNIQUE_LIGHTUSERDATA_MASK(&index));

	CS = lua_touserdata(L, -1);

	lua_pop(L, 1);

	if (CS)
		return CS;

	CS = lua_newuserdata(L, sizeof *CS);
	memset(CS, 0, sizeof *CS);

	LIST_INIT(&CS->cqueues);

	lua_rawsetp(L, LUA_REGISTRYINDEX, CQS_UNIQUE_LIGHTUSERDATA_MASK(&index));

	return CS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2438a(%rip), %rdx     # 0x35500
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf080
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10350
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testq %r14, %r14
jne 0x111cc
movl $0x10, %esi
movq %rbx, %rdi
callq 0xfb00
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x24341(%rip), %rdx     # 0x35500
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf160
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.h
// Function: cqs_requiref
static void cqs_requiref(lua_State *L, const char *modname, lua_CFunction openf, int glb) {
	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
	lua_getfield(L, -1, modname);
	lua_remove(L, -2);

	if (lua_isnil(L, -1)) {
		lua_pop(L, 1);
		luaL_requiref(L, modname, openf, glb);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x23c65(%rip), %rdx     # 0x35157
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x10430
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0xf1e0
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xf0e0
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
testl %eax, %eax
je 0x11542
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xfdb0
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: luaopen__cqueues_debug
int luaopen__cqueues_debug(lua_State *L) {
	luaL_newlib(L, dbg_globals);

	lua_pushinteger(L, INT_MAX);
	lua_setfield(L, -2, "INT_MAX");

	lua_pushinteger(L, LONG_MAX);
	lua_setfield(L, -2, "LONG_MAX");

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x23a90(%rip), %xmm0    # 0x35000
movl $0x88, %esi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x101e0
leaq 0x367d0(%rip), %rsi     # 0x47d60
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0xf910
leaq 0x23b56(%rip), %rdx     # 0x35104
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
callq 0xf910
leaq 0x23b38(%rip), %rdx     # 0x3510c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: auxlib_tostring
static int auxlib_tostring(lua_State *L) {
	luaL_checkany(L, 1);

	if (luaL_getmetafield(L, 1, "__tostring")) {
		lua_insert(L, 1);
		lua_settop(L, 2);
		lua_callk(L, 1, 1, 0, &auxlib_tostringk);

		return auxlib_tostringk(L, LUA_OK, 0);
	} else {
		luaL_tolstring(L, 1, NULL);

		return 1;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x105d0
leaq 0x23b18(%rip), %rdx     # 0x35115
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfdc0
testl %eax, %eax
je 0x11652
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xf0e0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10640
leaq 0x34(%rip), %r8         # 0x11668
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xf670
movq %rbx, %rdi
callq 0x11668
jmp 0x11661
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xfcb0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: auxlib_tostringk
LUA_KFUNCTION(auxlib_tostringk) {
	if (luaL_getmetafield(L, 1, "__tostring")) {
		lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
	} else {
		luaL_tolstring(L, 1, NULL);
	}

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x23a9f(%rip), %rdx     # 0x35115
movl $0x1, %esi
callq 0xfdc0
testl %eax, %eax
je 0x116c4
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf260
movq %rbx, %rdi
movl %eax, %esi
callq 0xfa50
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10080
leaq 0x23a6e(%rip), %rsi     # 0x35120
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfff0
jmp 0x116d3
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xfcb0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cond_wait
static int cond_wait(lua_State *L) {
	cond_checkself(L, 1);

	lua_pushlightuserdata(L, CQUEUE__POLL);
	lua_insert(L, 1);

	return lua_yield(L, lua_gettop(L));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x23965(%rip), %rsi     # 0x35050
callq 0x11852
movq 0x35869(%rip), %rsi     # 0x46f60
movq %rbx, %rdi
callq 0x10150
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xf0e0
movq %rbx, %rdi
callq 0xf920
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0xf0b0
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cond_signal
static int cond_signal(lua_State *L) {
	struct condition *cv = cond_checkself(L, 1);
	int i, n = luaL_optint(L, 2, INT_MAX);
	struct wakecb *cb;
	int error;

	for (i = 0; i < n && !TAILQ_EMPTY(&cv->waiting); i++) {
		cb = TAILQ_FIRST(&cv->waiting);
		wakecb_del(cb);

		if ((error = cb->fn(cb)))
			goto error;
	}

	lua_pushinteger(L, i);

	return 1;
error:
	lua_pushnil(L);
	lua_pushstring(L, cqs_strerror(error));
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x2390f(%rip), %rsi     # 0x35050
callq 0x11852
movq %rax, %r15
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf400
movq %rax, %r12
xorl %r14d, %r14d
testl %r12d, %r12d
jle 0x117b0
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x117ad
movq (%rdi), %rax
testq %rax, %rax
je 0x1179b
movq 0x28(%rdi), %rcx
addq $0x10, %rax
leaq 0x30(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rax, %rdx
movq 0x30(%rdi), %rax
movq %rax, (%rdx)
movq %rcx, (%rax)
movq $0x0, (%rdi)
callq *0x8(%rdi)
testl %eax, %eax
jne 0x117c2
incl %r14d
cmpl %r14d, %r12d
jne 0x11766
movl %r12d, %r14d
movl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
movl $0x1, %eax
jmp 0x11818
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.h
// Function: cqs_checkudata
static inline void *cqs_checkudata(lua_State *L, int index, int upvalue, const char *tname) {
	void *ud;

	if (!(ud = cqs_testudata(L, index, upvalue))) {
		index = lua_absindex(L, index);

		luaL_argerror(L, index, lua_pushfstring(L, "%s expected, got %s", tname, luaL_typename(L, index)));

		NOTREACHED;
	}

	return ud;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x10350
testq %rax, %rax
je 0x118b5
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0xf900
testl %eax, %eax
je 0x118b5
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xf6b0
movl %eax, %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testl %ebp, %ebp
je 0x118b5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a90
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.h
// Function: cqs_setfuncsupvalue
static inline void cqs_setfuncsupvalue(lua_State *L, int tindex, int n) {
	tindex = lua_absindex(L, tindex);

	lua_pushnil(L);
	while (lua_next(L, tindex)) {
		if (lua_iscfunction(L, -1)) {
			lua_pushvalue(L, -3);
			lua_setupvalue(L, -2, n);
		}

		lua_pop(L, 1); /* pop field value (leaving key) */
	}

	lua_pop(L, 1); /* pop upvalue */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
callq 0xf280
movl %eax, %ebp
movq %r14, %rdi
callq 0xf980
movq %r14, %rdi
movl %ebp, %esi
callq 0x10760
testl %eax, %eax
je 0x11989
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf120
testl %eax, %eax
je 0x1197a
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xf9c0
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %ebx, %edx
callq 0xf370
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
jmp 0x1193f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %rbp
jmp 0x10640
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cond_type
static int cond_type(lua_State *L) {
	if (cond_testself(L, 1)) {
		lua_pushstring(L, "condition");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10350
testq %rax, %rax
je 0x11a45
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf900
testl %eax, %eax
je 0x11a45
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xf6b0
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testl %ebp, %ebp
je 0x11a45
leaq 0x23647(%rip), %rsi     # 0x35082
movq %rbx, %rdi
callq 0xfbd0
jmp 0x11a4d
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_cancelfd
static cqs_error_t cqueue_cancelfd(struct cqueue *Q, int fd) {
	struct fileno *fileno;
	int error = 0, _error;

	if (!(fileno = fileno_find(Q, fd)))
		return 0;

	if ((_error = fileno_signal(Q, fileno, POLLIN|POLLOUT|POLLPRI)))
		error = _error;
	if ((_error = fileno_ctl(Q, fileno, 0)))
		error = _error;

	return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1a0(%rdi), %r14
testq %r14, %r14
je 0x11b04
movq %rdi, %rbx
movl $0x10, %eax
cmpl %esi, (%r14)
jg 0x11afb
movl $0x18, %eax
je 0x11b0c
movq (%r14,%rax), %r14
testq %r14, %r14
jne 0x11aea
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %edx
callq 0x11b30
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11bbe
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: fileno_signal
static cqs_error_t fileno_signal(struct cqueue *Q, struct fileno *fileno, short events) {
	struct event *event;
	int error = 0, _error;

	LIST_FOREACH(event, &fileno->events, fle) {
		/* XXX: If POLLPRI should we always mark as pending? */
		if (event->events & events)
			event->pending = 1;

		thread_move(event->thread, &Q->thread.pending);

		if ((_error = cqueue_tryalert(Q)))
			error = _error;
	}

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x11bb1
movl %edx, %ebx
movq %rdi, %r14
leaq 0x210(%rdi), %r12
xorl %ebp, %ebp
testw %bx, 0x4(%r15)
je 0x11b5b
movb $0x1, 0x10(%r15)
movq 0x18(%r15), %rax
cmpq %r12, 0x20(%rax)
je 0x11b99
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rsi
testq %rcx, %rcx
je 0x11b76
movq %rsi, 0x30(%rcx)
leaq 0x28(%rax), %rdx
movq %rcx, (%rsi)
movq (%r12), %rcx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x11b8d
movq %rdx, 0x30(%rcx)
movq %rax, (%r12)
movq %r12, 0x30(%rax)
movq %r12, 0x20(%rax)
movq %r14, %rdi
callq 0x11c34
testl %eax, %eax
cmovnel %eax, %ebp
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x11b4f
jmp 0x11bb3
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: fileno_ctl
static int fileno_ctl(struct cqueue *Q, struct fileno *fileno, short events) {
	int error;

	if ((error = kpoll_ctl(&Q->kp, fileno->fd, &fileno->state, events, fileno)))
		return error; /* XXX: Should we call fileno_signal? */

	LIST_REMOVE(fileno, le);

	if (fileno->state)
		LIST_INSERT_HEAD(&Q->fileno.polling, fileno, le);
	else
		LIST_INSERT_HEAD(&Q->fileno.inactive, fileno, le);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %esi
leaq 0x4(%rbx), %rdx
movq %rbx, %r8
callq 0x11d4f
testl %eax, %eax
jne 0x11c2c
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
testq %rdx, %rdx
je 0x11bed
movq %rsi, 0x38(%rdx)
leaq 0x30(%rbx), %rcx
movq %rdx, (%rsi)
cmpw $0x0, 0x4(%rbx)
je 0x11c0b
movq 0x1a8(%r14), %rdx
addq $0x1a8, %r14            # imm = 0x1A8
jmp 0x11c19
movq 0x1b8(%r14), %rdx
addq $0x1b8, %r14            # imm = 0x1B8
movq %rdx, (%rcx)
testq %rdx, %rdx
je 0x11c25
movq %rcx, 0x38(%rdx)
movq %rbx, (%r14)
movq %r14, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_tryalert
static cqs_error_t cqueue_tryalert(struct cqueue *Q) {
	if (!cstack_isrunning(Q->cstack, Q) || LIST_EMPTY(&Q->thread.pending)) {
		return kpoll_alert(&Q->kp);
	} else {
		return 0;
	}
}

// Assembly:
movq 0x230(%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x11c61
jmp 0x11c4f
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x11c61
cmpq %rdi, (%rax)
jne 0x11c46
cmpq $0x0, 0x210(%rdi)
je 0x11c61
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: kpoll_alert
static int kpoll_alert(struct kpoll *kp) {
	int error;

	if (kp->alert.pending)
		return 0;

	/* initialization may have been delayed */
	if ((error = alert_init(kp)))
		return error;
#if ENABLE_PORTS
	if (0 != port_send(kp->fd, POLLIN, &kp->alert)) {
		if (errno != EBUSY)
			return errno;
	}
#elif HAVE_EVENTFD
	static const uint64_t one = 1;

	while (-1 == write(kp->alert.fd[0], &one, sizeof one)) {
		if (errno == EAGAIN) {
			break;
		} else if (errno != EINTR) {
			return errno;
		}
	}
#else
	while (-1 == write(kp->alert.fd[1], "!", 1)) {
		if (errno == EAGAIN) {
			break;
		} else if (errno != EINTR) {
			return errno;
		}
	}
#endif
	if ((error = alert_rearm(kp)))
		return error;

	kp->alert.pending = 1;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, 0x19c(%rdi)
jne 0x11cd9
movq %rdi, %r14
callq 0x11cf4
testl %eax, %eax
jne 0x11cd7
leaq 0x190(%r14), %r15
leaq 0x2386a(%rip), %r12     # 0x354f8
movl (%r15), %edi
movl $0x8, %edx
movq %r12, %rsi
callq 0xf4a0
cmpq $-0x1, %rax
jne 0x11cb5
callq 0xf0a0
movl (%rax), %eax
cmpl $0x4, %eax
je 0x11c8e
cmpl $0xb, %eax
jne 0x11cd7
movl 0x190(%r14), %esi
leaq 0x198(%r14), %rdx
movq %r14, %rdi
movl $0x1, %ecx
movq %r15, %r8
callq 0x11d4f
testl %eax, %eax
je 0x11ce7
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x1, 0x19c(%r14)
jmp 0x11cd9
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: alert_init
static int alert_init(struct kpoll *kp) {
#if ENABLE_PORTS
	(void)kp;
	return 0;
#elif HAVE_EVENTFD
	if (kp->alert.fd[0] != -1)
		return 0;

	if (-1 == (kp->alert.fd[0] = eventfd(0, O_CLOEXEC|O_NONBLOCK)))
		return errno;

	return alert_rearm(kp);
#else
	int error;

	if (kp->alert.fd[0] != -1)
		return 0;

	if ((error = cqs_pipe(kp->alert.fd, O_CLOEXEC|O_NONBLOCK)))
		return error;

	return alert_rearm(kp);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpl $-0x1, 0x190(%rdi)
je 0x11d0b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
leaq 0x190(%rdi), %r14
xorl %edi, %edi
movl $0x80800, %esi          # imm = 0x80800
callq 0xffe0
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x11d46
leaq 0x198(%rbx), %rdx
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %ecx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11d4f
callq 0xf0a0
movl (%rax), %eax
jmp 0x11d03
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_attach
static int cqueue_attach(lua_State *L) {
	struct callinfo I;
	struct cqueue *Q;
	int error;

	lua_settop(L, 2);

	Q = cqueue_enter(L, &I, 1);
	luaL_checktype(L, 2, LUA_TTHREAD);

	thread_add(L, Q, &I, 2);

	if ((error = cqueue_tryalert(Q)))
		goto error;

	lua_pushvalue(L, 1); /* return self */

	return 1;
error:
	lua_pushnil(L);
	lua_pushstring(L, cqs_strerror(error));
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movl $0x2, %esi
callq 0x10640
movq %rbx, %rdi
callq 0x12de1
movq %rax, %r14
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
leaq 0x8(%rsp), %r15
movl %eax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r15)
movl $0xffffffff, 0x14(%r15) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0xf6c0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x2, %ecx
callq 0x14c14
movq %r14, %rdi
callq 0x11c34
testl %eax, %eax
je 0x1234a
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf980
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %r14d, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %ebp
jmp 0x12357
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_wrap
static int cqueue_wrap(lua_State *L) {
	struct callinfo I;
	struct cqueue *Q;
	struct lua_State *newL;
	int top, error;

	top = lua_gettop(L);

	Q = cqueue_enter(L, &I, 1);
	luaL_checktype(L, 2, LUA_TFUNCTION);

	newL = lua_newthread(L);
	lua_insert(L, 2);
	luaL_checkstack(newL, top - 1, "too many arguments");
	lua_xmove(L, newL, top - 1);

	thread_add(L, Q, &I, -1);

	if ((error = cqueue_tryalert(Q)))
		goto error;

	lua_pushvalue(L, 1); /* return self */

	return 1;
error:
	lua_pushnil(L);
	lua_pushstring(L, cqs_strerror(error));
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0xf920
movl %eax, %r15d
movq %rbx, %rdi
callq 0x12de1
movq %rax, %r14
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
leaq 0x8(%rsp), %r12
movl %eax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r12)
movl $0xffffffff, 0x14(%r12) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0xf6c0
movq %rbx, %rdi
callq 0x10a40
movq %rax, %r13
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xf0e0
decl %r15d
leaq 0x22d6b(%rip), %rdx     # 0x3515f
movq %r13, %rdi
movl %r15d, %esi
callq 0xfca0
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x10230
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x14c14
movq %r14, %rdi
callq 0x11c34
testl %eax, %eax
je 0x12488
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf980
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %r14d, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %ebp
jmp 0x12495
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_alert
static int cqueue_alert(lua_State *L) {
	struct cqueue *Q = cqueue_checkself(L, 1);
	int error;

	if ((error = kpoll_alert(&Q->kp)))
		goto error;

	lua_pushvalue(L, 1);

	return 1;
error:
	lua_pushnil(L);
	lua_pushstring(L, cqs_strerror(error));
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x12de1
movq %rax, %rdi
callq 0x11c61
testl %eax, %eax
je 0x1251e
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %ebp
jmp 0x12530
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_cancel
static int cqueue_cancel(lua_State *L) {
	struct callinfo I;
	int top = lua_gettop(L);
	struct cqueue *Q = cqueue_enter(L, &I, 1);
	int index;

	for (index = 2; index <= top; index++)
		cqueue_cancelfd(Q, cqueue_checkfd(L, &I, index));

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0xf920
movl %eax, %r14d
movq %rbx, %rdi
callq 0x12de1
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
movl %eax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
cmpl $0x2, %r14d
jl 0x12602
negl %r14d
movl $0x2, %r13d
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x14d16
movq %r15, %rdi
movl %eax, %esi
callq 0x11ad7
leal (%r14,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x125d7
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_reset
static int cqueue_reset(lua_State *L) {
	struct cqueue *Q = cqueue_checkself(L, 1);
	int error;

	if ((error = cqueue_reboot(Q, 1, 1)))
		return luaL_error(L, "unable to reset continuation queue: %s", cqs_strerror(error));

	return 0;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
callq 0x12de1
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x14dc6
testl %eax, %eax
jne 0x12643
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
movq %rsp, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x10adc
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_timeout
static int cqueue_timeout(lua_State *L) {
	struct cqueue *Q = cqueue_checkself(L, 1);

	if (!LIST_EMPTY(&Q->thread.pending)) {
		lua_pushnumber(L, 0.0);
	} else {
		double timeout = cqueue_timeout_(Q);

		if (isfinite(timeout))
			lua_pushnumber(L, timeout);
		else
			lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x12de1
cmpq $0x0, 0x210(%rax)
je 0x12916
pxor %xmm0, %xmm0
jmp 0x12945
movq 0x228(%rax), %rdi
callq 0x129d6
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x12945
movq %rbx, %rdi
callq 0xf980
jmp 0x1294d
movq %rbx, %rdi
callq 0xf2c0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_close
static int cqueue_close(lua_State *L) {
	struct cqueue *Q = cqs_checkudata(L, 1, 1, CQUEUE_CLASS);
	struct callinfo I;

	/* disallow :close when invoked from a thread resumed by cqueue_step */
	luaL_argcheck(L, !Q->cstack || !cstack_isrunning(Q->cstack, Q), 1, "cqueue running");

	cqueue_enter_nothrow(L, &I, 1, Q);
	cqueue_destroy(L, Q, &I);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x22727(%rip), %rsi     # 0x3508c
callq 0x11852
movq %rax, %r14
movq 0x230(%rax), %rax
testq %rax, %rax
je 0x129a1
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x129a1
cmpq %r14, (%rax)
je 0x1298d
movq 0x20(%rax), %rax
jmp 0x1297d
leaq 0x22b1a(%rip), %rdx     # 0x354ae
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf3f0
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
movq %rsp, %rdx
movl %eax, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdx)
movl $0xffffffff, 0x14(%rdx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14f9a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_timeout_
static double cqueue_timeout_(struct cqueue *Q) {
	struct timer *timer;
	double curtime;

	if (!(timer = LLRB_MIN(timers, &Q->timers)))
		return NAN;

	curtime = monotime();

	return (islessequal(timer->timeout, curtime))? 0.0 : timer->timeout - curtime;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd 0x22623(%rip), %xmm0    # 0x35008
testq %rdi, %rdi
je 0x12a38
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x129e5
leaq 0x8(%rsp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0xfbf0
xorps %xmm0, %xmm0
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
divsd 0x22602(%rip), %xmm1    # 0x35020
addsd %xmm0, %xmm1
movsd (%r14), %xmm0
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
cmpnlesd %xmm1, %xmm0
andpd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_step_cont
static int cqueue_step_cont(lua_State *L) {
#endif
	int nargs = lua_gettop(L);
	struct callinfo I = CALLINFO_INITIALIZER;
	struct cqueue *Q = cqueue_checkself(L, 1);
	struct thread *T = Q->thread.current;
	if (!T) {
		luaL_error(L, "cqueue not yielded");
		NOTREACHED;
	}
	if (lua_islightuserdata(L, 2) && lua_touserdata(L, 2) == CQUEUE__POLL) {
		luaL_error(L, "cannot resume a coroutine passing internal cqueues._POLL value as first parameter");
		NOTREACHED;
	}
	/* move arguments onto resumed stack */
	lua_xmove(L, T->L, nargs-1);

	cqueue_enter(L, &I, 1);

	switch(cqueue_process_threads(L, Q, &I)) {
	case LUA_OK:
		break;
	case LUA_YIELD:
		/* clear everything off the stack except for cqueue object; `I` now invalid */
		lua_settop(L, 1);
#if LUA_VERSION_NUM >= 502
		/* move arguments onto 'main' stack to return them from this yield */
		nargs = lua_gettop(Q->thread.current->L);
		lua_xmove(Q->thread.current->L, L, nargs);
		return lua_yieldk(L, nargs, 0, cqueue_step_cont);
#else
		lua_pushliteral(L, "yielded");
		/* move arguments onto 'main' stack to return them from this yield */
		nargs = lua_gettop(Q->thread.current->L);
		lua_xmove(Q->thread.current->L, L, nargs);
		return nargs+1;
#endif
	default:
		goto oops;
	}

	lua_pushboolean(L, 1);

	return 1;
oops:
	Q->thread.current = NULL;
	lua_pushboolean(L, 0);
	return 1 + err_pushinfo(L, &I);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xf920
movl %eax, %ebp
movq %rbx, %rdi
callq 0x12de1
movq 0x218(%rax), %r15
testq %r15, %r15
je 0x12c86
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf260
cmpl $0x2, %eax
jne 0x12ba7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10350
cmpq 0x343bf(%rip), %rax     # 0x46f60
je 0x12c8f
movq (%r15), %rsi
decl %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x10230
movq %rbx, %rdi
callq 0x12de1
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
movq %rsp, %rdx
movl %eax, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdx)
movl $0xffffffff, 0x14(%rdx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e20
testl %eax, %eax
je 0x12c46
cmpl $0x1, %eax
jne 0x12c55
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10640
movq 0x218(%r14), %rax
movq (%rax), %rdi
callq 0xf920
movl %eax, %ebp
movq 0x218(%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x10230
leaq -0xe4(%rip), %rcx       # 0x12b4c
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf0b0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x12c79
movq $0x0, 0x218(%r14)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12ca0
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22708(%rip), %rsi     # 0x35395
jmp 0x12c96
leaq 0x22712(%rip), %rsi     # 0x353a8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd60
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: err_pushinfo
static cqs_nargs_t err_pushinfo(lua_State *L, struct callinfo *I) {
	int nargs = 0;

	luaL_checkstack(L, 5, "too many arguments");

	err_pushvalue(L, I);
	nargs = 1;

	if (I->error.code) {
		lua_pushinteger(L, I->error.code);
		nargs = 2;
	}

	if (I->error.thread) {
		lua_settop(L, lua_gettop(L) + (2 - nargs));
		err_checktype(L, I->error.thread, LUA_TTHREAD);
		lua_pushvalue(L, I->error.thread);
		nargs = 3;
	}

	if (I->error.object) {
		lua_settop(L, lua_gettop(L) + (3 - nargs));
		if (lua_isnone(L, I->error.object))
			err_corrupt(L, I->error.object, "any");
		lua_pushvalue(L, I->error.object);
		nargs = 4;
	}

	if (I->error.fd != -1) {
		lua_settop(L, lua_gettop(L) + (4 - nargs));
		lua_pushinteger(L, I->error.fd);
		nargs = 5;
	}

	return nargs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x224ab(%rip), %rdx     # 0x3515f
movl $0x5, %esi
callq 0xfca0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x14bae
movslq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x12ce3
movq %rbx, %rdi
callq 0xf910
movl $0x2, %r15d
jmp 0x12ce9
movl $0x1, %r15d
cmpl $0x0, 0xc(%r14)
je 0x12d33
movq %rbx, %rdi
callq 0xf920
negl %r15d
leal (%rax,%r15), %esi
addl $0x2, %esi
movq %rbx, %rdi
callq 0x10640
movl 0xc(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf260
cmpl $0x8, %eax
jne 0x12db8
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xf9c0
movl $0x3, %r15d
cmpl $0x0, 0x10(%r14)
je 0x12d77
movq %rbx, %rdi
callq 0xf920
negl %r15d
leal (%rax,%r15), %esi
addl $0x3, %esi
movq %rbx, %rdi
callq 0x10640
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xf260
movl 0x10(%r14), %esi
cmpl $-0x1, %eax
je 0x12dd2
movq %rbx, %rdi
callq 0xf9c0
movl $0x4, %r15d
cmpl $-0x1, 0x14(%r14)
je 0x12daa
movq %rbx, %rdi
callq 0xf920
negl %r15d
leal (%rax,%r15), %esi
addl $0x4, %esi
movq %rbx, %rdi
callq 0x10640
movslq 0x14(%r14), %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x5, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x8, %esi
callq 0xfa50
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x14bdf
leaq 0x22621(%rip), %rdx     # 0x353fa
movq %rbx, %rdi
callq 0x14bdf
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: event_del
static void event_del(struct cqueue *Q, struct event *event) {
	if (event->wakecb) {
		wakecb_del(event->wakecb);
		pool_put(&Q->pool.wakecb, event->wakecb);
	}

	if (event->fileno) {
		LIST_REMOVE(event->fileno, le);
		LIST_INSERT_HEAD(&Q->fileno.outstanding, event->fileno, le);

		LIST_REMOVE(event, fle);
	}

	TAILQ_REMOVE(&event->thread->events, event, tqe);
	assert(event->thread->count > 0);
	event->thread->count--;

	pool_put(&Q->pool.event, event);
}

// Assembly:
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x13dfc
movq (%rax), %rcx
testq %rcx, %rcx
je 0x13deb
movq 0x28(%rax), %rdx
movq 0x30(%rax), %r8
addq $0x10, %rcx
leaq 0x30(%rdx), %r9
testq %rdx, %rdx
cmoveq %rcx, %r9
movq %r8, (%r9)
movq %rdx, (%r8)
movq $0x0, (%rax)
movq 0x48(%rsi), %rax
movq 0x1d0(%rdi), %rcx
movq %rcx, (%rax)
movq %rax, 0x1d0(%rdi)
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x13e57
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
testq %rax, %rax
je 0x13e16
movq %rcx, 0x38(%rax)
movq %rax, (%rcx)
leaq 0x1b0(%rdi), %rax
movq 0x1b0(%rdi), %rdx
movq 0x30(%rsi), %rcx
movq %rdx, 0x30(%rcx)
testq %rdx, %rdx
je 0x13e3c
leaq 0x30(%rcx), %r8
movq %r8, 0x38(%rdx)
movq %rcx, (%rax)
movq %rax, 0x38(%rcx)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rcx
testq %rax, %rax
je 0x13e54
movq %rcx, 0x40(%rax)
movq %rax, (%rcx)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
testq %rax, %rax
je 0x13e6a
leaq 0x28(%rax), %rdx
jmp 0x13e72
movq 0x18(%rsi), %rdx
addq $0x10, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
movq 0x18(%rsi), %rax
movl 0x18(%rax), %ecx
testl %ecx, %ecx
je 0x13e9a
decl %ecx
movl %ecx, 0x18(%rax)
movq 0x200(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x200(%rdi)
retq
pushq %rax
leaq 0x213f0(%rip), %rdi     # 0x35292
leaq 0x21351(%rip), %rsi     # 0x351fa
leaq 0x213fb(%rip), %rcx     # 0x352ab
movl $0x720, %edx            # imm = 0x720
callq 0xf890
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_update
static cqs_status_t cqueue_update(lua_State *L, struct cqueue *Q, struct callinfo *I, struct thread *T) {
	struct fileno *fileno, *next;
	struct event *event;
	int error;

	for (fileno = LIST_FIRST(&Q->fileno.outstanding); fileno; fileno = next) {
		next = LIST_NEXT(fileno, le);

		if ((error = fileno_update(Q, fileno)))
			goto error;
	}

	return LUA_OK;
error:
	LIST_FOREACH(event, &fileno->events, fle) {
		if (event->thread != T)
			continue;

		lua_pushvalue(T->L, event->index);
		lua_xmove(T->L, L, 1);
		err_setobject(L, I, lua_gettop(L));

		break;
	}

	err_setfd(L, I, fileno->fd);
	err_setinfo(L, I, error, T, 0, "unable to update event disposition: %s (fd:%d)", cqs_strerror(error), fileno->fd);

	return LUA_ERRRUN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq 0x1b0(%rsi), %r12
testq %r12, %r12
je 0x145ba
movq %r12, %r15
movq 0x8(%r12), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x14580
orw 0x4(%rcx), %ax
movq 0x38(%rcx), %rcx
jmp 0x14571
movq 0x30(%r15), %r12
movswl %ax, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x11bbe
testl %eax, %eax
je 0x14562
movl %eax, %ebp
movq 0x8(%r15), %rax
testq %rax, %rax
movq %r14, %r12
movq 0x8(%rsp), %r14
je 0x145f6
cmpq %rbx, 0x18(%rax)
je 0x145c1
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x145a9
jmp 0x145f6
xorl %eax, %eax
jmp 0x1465f
movq (%rbx), %rdi
movl 0x14(%rax), %esi
callq 0xf9c0
movq (%rbx), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x10230
movq %r12, %rdi
callq 0xf920
testl %eax, %eax
je 0x145f6
movq %r12, %rdi
movl %eax, %esi
callq 0xf280
movl %eax, 0x10(%r14)
movl (%r15), %eax
movl %eax, 0x14(%r14)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rax, %r10
movl (%r15), %r11d
leaq 0x20d29(%rip), %r9      # 0x35366
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x14770
addq $0x10, %rsp
movl $0x2, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: thread_del
static void thread_del(lua_State *L, struct cqueue *Q, struct callinfo *I, struct thread *T) {
	struct event *event;

	while ((event = TAILQ_FIRST(&T->events))) {
		event_del(Q, event);
	}
	timer_destroy(Q, &T->timer);
	LIST_REMOVE(T, le);
	Q->thread.count--;

	/*
	 * XXX: These lua operations are documented as able to longjmp on
	 * OOM. However, inspection of the lua source suggests that when used
	 * as below they won't throw.
	 *   - In lua5.1 pushing a lightuserdata doesn't allocate (they're
	 *     stack allocated)
	 *   - rawset doesn't allocate if the key already exists in the table
	 *     (which it always does for this function)
	 */
	cqs_getuservalue(L, I->self);

	/* set thread's uservalue (it's thread) to nil */
	lua_rawgetp(L, -1, CQS_UNIQUE_LIGHTUSERDATA_MASK(T));
	lua_pushnil(L);
	cqs_setuservalue(L, -2);
	lua_pop(L, 1);
	T->L = NULL;

	/* remove thread from cqueues's thread table */
	lua_pushnil(L);
	lua_rawsetp(L, -2, CQS_UNIQUE_LIGHTUSERDATA_MASK(T));
	lua_pop(L, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x1469c
movq %r12, %rdi
callq 0x13db2
movq 0x8(%r14), %rsi
jmp 0x14689
leaq 0x40(%r14), %rsi
movq %r12, %rdi
callq 0x13eba
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
testq %rax, %rax
je 0x146b9
movq %rcx, 0x30(%rax)
movq %rax, (%rcx)
decl 0x220(%r12)
movl (%r15), %esi
movq %rbx, %rdi
callq 0x10330
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0xf080
movq %rbx, %rdi
callq 0xf980
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf630
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movq $0x0, (%r14)
movq %rbx, %rdi
callq 0xf980
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0xf160
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10640
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: err_setinfo
static void err_setinfo(lua_State *L, struct callinfo *I, int code, struct thread *T, int object, const char *fmt, ...) {
	/* set object first in case it's a relative index */
	if (object)
		err_setobject(L, I, object);

	if (T)
		err_setthread(L, I, T);

	if (fmt) {
		va_list ap;

		va_start(ap, fmt);
		err_setvfstring(L, I, fmt, ap);
		va_end(ap);
	}

	/*
	 * set code after we set any string so we don't unnecessarily
	 * instantiate a string description
	 */
	if (code)
		err_setcode(L, I, code);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %r9, %r12
movq %rcx, %r13
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testb %al, %al
je 0x147c9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %r8d, %r8d
je 0x147dd
movq %r15, %rdi
movl %r8d, %esi
callq 0xf280
movl %eax, 0x10(%r14)
testq %r13, %r13
je 0x147f0
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x14738
testq %r12, %r12
je 0x14831
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x10600
movq %r15, %rdi
callq 0xf920
movl %eax, 0x4(%r14)
testl %ebx, %ebx
je 0x14842
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12add
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: pool_get
static void *pool_get(struct pool *P, int *_error) {
	void *p;
	int error;

	if (!(p = P->head)) {
		error = pool_grow(P, MAX(1, P->count));

		if (!(p = P->head)) {
			*_error = error;

			return NULL;
		}
	}

	P->head = *(void **)p;

	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0x148c3
movq %rsi, %r14
movq 0x8(%rbx), %r12
cmpq $0x1, %r12
movq %r12, %r13
adcq $0x0, %r13
incq %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x148ad
movq (%rbx), %rdi
callq 0x10110
testq %rax, %rax
je 0x148b4
decq %r13
movq %r12, 0x8(%rbx)
movq %r15, (%rax)
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r15
testq %r13, %r13
jne 0x14880
jmp 0x148c3
movl $0xc, %ecx
jmp 0x148bb
callq 0xf0a0
movl (%rax), %ecx
movq %r15, %rax
testq %r15, %r15
je 0x148d4
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %ecx, (%r14)
xorl %eax, %eax
jmp 0x148ca
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: object_getcv
static int object_getcv(lua_State *L, struct cqueue *Q, struct callinfo *I, struct thread *T, int index, struct event *event) {
	struct condition *cv = lua_touserdata(L, index);
	int error;

	if (!(event->wakecb = pool_get(&Q->pool.wakecb, &error))) {
		err_setinfo(L, I, error, T, index, "unable to wait on conditional variable: %s", cqs_strerror(error));

		return LUA_ERRRUN;
	}

	wakecb_init(event->wakecb, &wakecb_wakeup, Q, event);
	wakecb_add(event->wakecb, cv);

	return LUA_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10350
movq %rax, %r14
leaq 0x1c0(%rbp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x14853
movq %rax, 0x48(%r13)
testq %rax, %rax
je 0x1497d
movq $0x0, (%rax)
leaq 0x223(%rip), %rcx       # 0x14b53
movq %rcx, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x48(%r13), %rax
movq %r13, 0x18(%rax)
movq 0x48(%r13), %rax
cmpb $0x1, (%r14)
jne 0x149de
leaq 0x8(%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x28(%rax), %rsi
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x30(%rdx), %r8
testq %rdx, %rdx
cmoveq %rdi, %r8
movq %rdx, 0x28(%rax)
movq %rsi, (%r8)
movq %rax, 0x8(%r14)
movq %rcx, 0x30(%rax)
jmp 0x149f9
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rax, (%rsp)
leaq 0x20934(%rip), %r9      # 0x352f3
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x14770
movl $0x2, %eax
jmp 0x149fe
leaq 0x28(%rax), %rcx
movq $0x0, 0x28(%rax)
movq 0x10(%r14), %rdx
movq %rdx, 0x30(%rax)
movq %rax, (%rdx)
movq %rcx, 0x10(%r14)
movq %r14, (%rax)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: object_pcall
static cqs_status_t (object_pcall)(lua_State *L, struct callinfo *I, struct thread *T, int index, const char *field, int rtype[], int n) {
	int type, i, status;

	index = lua_absindex(L, index);
	lua_getfield(L, index, field);

	if (lua_isfunction(L, -1)) {
		lua_pushvalue(L, index);

		if (LUA_OK != (status = lua_pcall(L, 1, 1, 0))) {
			err_setinfo(L, I, 0, T, index, "error calling method %s: %s", field, lua_tostring(L, -1));

			return status;
		}
	}

	type = lua_type(L, -1);

	for (i = 0; i < n; i++) {
		if (type == rtype[i])
			return LUA_OK;
	}

	err_setinfo(L, I, 0, T, index, "error loading field %s: %s expected, got %s", field, lua_typename(L, rtype[0]), luaL_typename(L, -1));

	return LUA_ERRRUN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, %esi
callq 0xf280
movl %eax, %ebp
movq %r12, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xf1e0
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
cmpl $0x6, %eax
jne 0x14ab9
movq %r12, %rdi
movl %ebp, %esi
callq 0xf9c0
movq %r12, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf990
testl %eax, %eax
je 0x14ab9
movl %eax, %r14d
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0xf110
movq %rax, %r10
leaq 0x20887(%rip), %r9      # 0x3531e
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq (%rsp), %rcx
movl %ebp, %r8d
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0x14770
addq $0x10, %rsp
jmp 0x14b41
movl 0x40(%rsp), %r14d
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
testl %r14d, %r14d
jle 0x14ae7
movl %r14d, %ecx
xorl %r14d, %r14d
xorl %edx, %edx
cmpl (%r13,%rdx,4), %eax
je 0x14b41
incq %rdx
cmpq %rdx, %rcx
jne 0x14ad8
movl (%r13), %esi
movq %r12, %rdi
callq 0xfa50
movq %rax, %r14
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
movq %r12, %rdi
movl %eax, %esi
callq 0xfa50
movq %rax, %r10
subq $0x8, %rsp
leaq 0x2081f(%rip), %r9      # 0x3533a
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq 0x8(%rsp), %rcx
movl %ebp, %r8d
xorl %eax, %eax
pushq %r10
pushq %r14
pushq %rbx
callq 0x14770
addq $0x20, %rsp
movl $0x2, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq