LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x12ff0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0xf740
movq -0x10(%rbp), %rdi
callq 0x10c50
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xf0f0
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %esi
subl $0x1, %esi
leaq 0x3597e(%rip), %rdx     # 0x481d3
callq 0xfdb0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
subl $0x1, %edx
callq 0x10380
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x16c10
movq -0x30(%rbp), %rdi
callq 0x121a0
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x12896
jmp 0x128ad
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xfa50
movl $0x1, -0x4(%rbp)
jmp 0x12917
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xcc(%rbp), %edi
leaq -0xc0(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0xfcc0
movq -0x10(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0xf9a0
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x13920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12250
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x12964
jmp 0x1297b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xfa50
movl $0x1, -0x4(%rbp)
jmp 0x129e5
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq -0x9c(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xac(%rbp), %edi
leaq -0x9c(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0xfcc0
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x12ff0
movq %rax, -0x30(%rbp)
movl $0x2, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x12afb
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq 0x16da0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x11da0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12ac5
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x13920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x16e90
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x12ba2
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xb4(%rbp), %edi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0x35920(%rip), %rsi     # 0x484b8
movb $0x0, %al
callq 0xfe70
movl %eax, -0x20(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13920
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x210(%rax)
je 0x12eda
movq -0x8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xf300
jmp 0x12f30
movq -0x10(%rbp), %rdi
callq 0x130f0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x12f15
jmp 0x12f25
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0xf300
jmp 0x12f2e
movq -0x8(%rbp), %rdi
callq 0xfa10
jmp 0x12f30
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %edx
leaq 0x351a4(%rip), %rcx     # 0x48100
movl %edx, %esi
callq 0x118d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x230(%rcx)
movb %al, -0x29(%rbp)
je 0x12fba
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12200
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x12f9c
jmp 0x12fba
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x35576(%rip), %rdx     # 0x48522
callq 0xf440
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x138b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x17460
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: mintimeout
static inline double mintimeout(double a, double b) {
	if (islessequal(a, b) || !isfinite(b))
		return a;
	else if (islessequal(b, a) || !isfinite(a))
		return b;
	else
		return NAN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x13089
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x13095
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x130e9
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x130d0
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x130dc
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x130e9
movsd 0x34f24(%rip), %xmm0    # 0x48008
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rdi
callq 0x139c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13125
movsd 0x34eea(%rip), %xmm0    # 0x48008
movsd %xmm0, -0x8(%rbp)
jmp 0x13168
callq 0x13a00
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x1314c
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1315e
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: kpoll_wait
static int kpoll_wait(struct kpoll *kp, double timeout) {
#if ENABLE_EPOLL
	int n;

	if (-1 == (n = epoll_wait(kp->fd, kp->pending.event, (int)countof(kp->pending.event), f2ms(timeout))))
		return (errno == EINTR)? 0 : errno;

	kp->pending.count = n;

	return 0;
#elif ENABLE_PORTS
	kpoll_event_t *ke;
	uint_t n = 1;

	kp->pending.count = 0;

	if (0 != port_getn(kp->fd, kp->pending.event, countof(kp->pending.event), &n, f2ts(timeout)))
		return (errno == ETIME || errno == EINTR)? 0 : errno;

	kp->pending.count = n;

	return 0;
#elif ENABLE_KQUEUE
	int n;

	if (-1 == (n = kevent(kp->fd, NULL, 0, kp->pending.event, (int)countof(kp->pending.event), f2ts(timeout))))
		return (errno == EINTR)? 0 : errno;

	kp->pending.count = n;

	return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x13a60
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movl %eax, %ecx
movl $0x20, %edx
callq 0xf650
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x131f4
callq 0xf0a0
cmpl $0x4, (%rax)
jne 0x131e2
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x131ec
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1320a
movslq -0x1c(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x188(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: err_setfstring
static void err_setfstring(lua_State *L, struct callinfo *I, const char *fmt, ...) {
	va_list ap;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x13258
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x13bb0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
leaq 0x34a8c(%rip), %rdx     # 0x481d3
callq 0xfdb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16ae0
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x13782
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0xf9a0
movl $0x2, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x137de
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movq -0x20(%rbp), %rdi
movl %eax, %esi
movl $0x2, %eax
subl -0x14(%rbp), %eax
addl %eax, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl $0x8, %edx
callq 0x16b40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xfa50
movl $0x3, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x13851
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl $0x3, %eax
subl -0x14(%rbp), %eax
addl %eax, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xf280
cmpl $-0x1, %eax
jne 0x1383a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x34c39(%rip), %rdx     # 0x4846e
callq 0x16ba0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xfa50
movl $0x4, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
je 0x13899
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl $0x4, %eax
subl -0x14(%rbp), %eax
addl %eax, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rsi
callq 0xf9a0
movl $0x5, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_enter_nothrow
static struct cqueue *cqueue_enter_nothrow(lua_State *L, struct callinfo *I, int index, struct cqueue *Q) {
	I->self = lua_absindex(L, index);

	I->error.value = 0;
	I->error.code = 0;
	I->error.thread = 0;
	I->error.object = 0;
	I->error.fd = -1;

	return Q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf2a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: f2ms
static inline int f2ms(const double f) {
	double ms;

	switch (fpclassify(f)) {
	case FP_NORMAL:
		if (signbit(f))
			return 0;

		ms = ceil(f * 1000);

		return (ms > INT_MAX)? INT_MAX : ms;
	case FP_SUBNORMAL:
		return 1;
	case FP_ZERO:
		return 0;
	case FP_INFINITE:
	case FP_NAN:
	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x2, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl %eax, -0x1c(%rbp)
jne 0x13ab0
jp 0x13ab0
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x4, %eax
ja 0x13b93
movq -0x30(%rbp), %rax
leaq 0x345b9(%rip), %rcx     # 0x48060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x28(%rbp), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm0
movl %eax, -0x1c(%rbp)
jp 0x13a8a
movsd -0x28(%rbp), %xmm0
movaps 0x34584(%rip), %xmm1    # 0x48050
pand %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %eax
movsd 0x34536(%rip), %xmm1    # 0x48018
ucomisd %xmm1, %xmm0
movl %eax, -0x1c(%rbp)
jne 0x13aef
jp 0x13aef
jmp 0x13a8a
movsd -0x38(%rbp), %xmm1
movsd 0x34524(%rip), %xmm0    # 0x48020
movl $0x3, %eax
movl $0x4, %ecx
ucomisd %xmm1, %xmm0
cmovbel %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13a8a
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
jge 0x13b2e
movl $0x0, -0x4(%rbp)
jmp 0x13b9a
movsd 0x344fa(%rip), %xmm0    # 0x48030
mulsd -0x10(%rbp), %xmm0
callq 0xf1e0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x344d6(%rip), %xmm1    # 0x48028
ucomisd %xmm1, %xmm0
jbe 0x13b67
movsd 0x344c8(%rip), %xmm0    # 0x48028
movsd %xmm0, -0x40(%rbp)
jmp 0x13b71
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0x13b9a
movl $0x1, -0x4(%rbp)
jmp 0x13b9a
movl $0x0, -0x4(%rbp)
jmp 0x13b9a
jmp 0x13b93
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_process_threads
static cqs_status_t cqueue_process_threads(lua_State *L, struct cqueue *Q, struct callinfo *I) {
	cqs_status_t status;
	struct thread *nxt;

	for (; Q->thread.current; Q->thread.current = nxt) {
		nxt = LIST_NEXT(Q->thread.current, le);

		if (LUA_OK != (status = cqueue_resume(L, Q, I, Q->thread.current))) {
			return status;
		}
	}

	return LUA_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x218(%rax)
je 0x13dc7
movq -0x18(%rbp), %rax
movq 0x218(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x218(%rax), %rcx
callq 0x13e70
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x13db4
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13dce
jmp 0x13db6
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x218(%rax)
jmp 0x13d64
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: kpoll_calm
static int kpoll_calm(struct kpoll *kp) {
	int error;

#if ENABLE_PORTS
	/* each PORT_SOURCE_USER event is discrete */
#elif HAVE_EVENTFD
	uint64_t n;

	while (-1 == read(kp->alert.fd[0], &n, sizeof n)) {
		if (errno == EAGAIN) {
			break;
		} else if (errno != EINTR) {
			return errno;
		}
	}
#else
	for (;;) {
		char buf[64];
		ssize_t n;

		if (-1 == (n = read(kp->alert.fd[0], buf, sizeof buf))) {
			if (errno == EAGAIN) {
				break;
			} else if (errno != EINTR) {
				return errno;
			}
		} else if (n == 0) {
			return EPIPE; /* somebody closed our fd! */
		}
	}
#endif
	if ((error = alert_rearm(kp)))
		return error;

	kp->alert.pending = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x190(%rax), %edi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x10470
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x13e39
callq 0xf0a0
cmpl $0xb, (%rax)
jne 0x13e1f
jmp 0x13e39
callq 0xf0a0
cmpl $0x4, (%rax)
je 0x13e35
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x13e67
jmp 0x13e37
jmp 0x13dec
movq -0x10(%rbp), %rdi
callq 0x12390
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x13e52
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13e67
movq -0x10(%rbp), %rax
movl $0x0, 0x19c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: auxL_xcopy
static _Bool auxL_xcopy(lua_State *from, lua_State *to, int count) {
	int index;

	if (!lua_checkstack(from, count)
	||  !lua_checkstack(to, count + LUA_MINSTACK))
		return 0;

	for (index = 1; index <= count; index++)
		lua_pushvalue(from, index);

	lua_xmove(from, to, count);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x10240
cmpl $0x0, %eax
je 0x14318
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl $0x14, %esi
callq 0x10240
cmpl $0x0, %eax
jne 0x1431e
movb $0x0, -0x1(%rbp)
jmp 0x14358
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x14344
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xfa50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x14325
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x10380
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x143b0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x11a20
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x14db0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x144a5
jmp 0x143c1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x143ec
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
jmp 0x14409
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
je 0x14441
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1b0(%rax)
movq -0x8(%rbp), %rcx
addq $0x1a0, %rcx            # imm = 0x1A0
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
jmp 0x14471
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x14490
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, (%rax)
jmp 0x144a5
jmp 0x144a7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x144c8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x144dc
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x18(%rax)
jbe 0x144ff
jmp 0x1451e
leaq 0x33e00(%rip), %rdi     # 0x48306
leaq 0x33d61(%rip), %rsi     # 0x4826e
movl $0x720, %edx            # imm = 0x720
leaq 0x33e06(%rip), %rcx     # 0x4831f
callq 0xf920
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x14db0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x148e0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x167c0
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x148d4
jmp 0x148ec
jmp 0x148d6
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x148aa
movl $0x0, -0x4(%rbp)
jmp 0x14a32
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1497e
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0x1490f
jmp 0x1496d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movl 0x14(%rax), %esi
callq 0xfa50
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x10380
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movl %eax, %edx
callq 0x16820
jmp 0x1497e
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x148f8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movl (%rax), %edx
callq 0x16860
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0xc4(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xfc(%rbp), %edi
leaq -0xc4(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movl -0xe4(%rbp), %edx
movq -0xe0(%rbp), %rcx
movq %rax, %r10
movq -0x30(%rbp), %rax
movl (%rax), %eax
xorl %r8d, %r8d
leaq 0x339be(%rip), %r9      # 0x483da
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x14cc0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: timer_add
static void timer_add(struct cqueue *Q, struct timer *timer, double timeout) {
	timer_del(Q, timer);

	if (isfinite(timeout)) {
		timer->timeout = timeout;
		LLRB_INSERT(timers, &Q->timers, timer);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14550
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x14a8f
jmp 0x14ab0
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
movq -0x10(%rbp), %rsi
callq 0x16880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: thread_timeout
static double thread_timeout(struct thread *T) {
	double timeout = NAN;
	struct event *event;

	TAILQ_FOREACH(event, &T->events, tqe) {
		timeout = mintimeout(timeout, event->timeout);
	}

	return timeout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd 0x33534(%rip), %xmm0    # 0x48008
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14b12
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
callq 0x13040
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x14ae5
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x14b59
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14370
jmp 0x14b38
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x40, %rsi
callq 0x16a50
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x14b89
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x220(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x220(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x16a80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf070
movq -0x8(%rbp), %rdi
callq 0xfa10
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x16ab0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0xfa10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf180
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x14cfe
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x14d2b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x16820
cmpq $0x0, -0x20(%rbp)
je 0x14d43
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14c30
cmpq $0x0, -0x30(%rbp)
je 0x14d87
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x13bb0
leaq -0x50(%rbp), %rax
cmpl $0x0, -0x14(%rbp)
je 0x14d9d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x132c0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x15747
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpq 0x8(%rcx), %rax
jbe 0x15704
movl $0x1, %eax
movq %rax, -0x38(%rbp)
jmp 0x15710
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15d30
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x15745
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1575e
jmp 0x15747
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: event_init
static void event_init(struct event *event, struct thread *T, int index) {
	memset(event, 0, sizeof *event);

	event->fd = -1;
	event->timeout = NAN;
	event->index = index;
	event->thread = T;

	TAILQ_INSERT_TAIL(&T->events, event, tqe);
	T->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xf7d0
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movsd 0x3285f(%rip), %xmm0    # 0x48008
movsd %xmm0, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: fileno_get
static struct fileno *fileno_get(struct cqueue *Q, int fd, int *error) {
	struct fileno *fileno;

	if (!(fileno = fileno_find(Q, fd))) {
		if (!(fileno = pool_get(&Q->pool.fileno, error)))
			return NULL;

		fileno->fd = fd;
		fileno->state = 0;
		LIST_INIT(&fileno->events);

		LIST_INSERT_HEAD(&Q->fileno.inactive, fileno, le);
		LLRB_INSERT(table, &Q->fileno.table, fileno);
	}

	return fileno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11e30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x15d17
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x156c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x15c8c
movq $0x0, -0x8(%rbp)
jmp 0x15d1f
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x15cad
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
je 0x15cdd
movq -0x28(%rbp), %rcx
addq $0x30, %rcx
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b8(%rax)
movq -0x10(%rbp), %rcx
addq $0x1a0, %rcx            # imm = 0x1A0
addq $0x18, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
movq -0x28(%rbp), %rsi
callq 0x16330
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: pool_grow
static int pool_grow(struct pool *P, size_t n) {
	void *p;
	int error;

	while (n--) {
		if (P->count + 1 == 0)
			return ENOMEM;

		if (!(p = make(P->size, &error)))
			return error;

		P->count++;

		pool_put(P, p);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x15db1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
cmpq $0x0, %rax
jne 0x15d70
movl $0xc, -0x4(%rbp)
jmp 0x15db8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x24(%rbp), %rsi
callq 0x15dd0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x15d92
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15db8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14db0
jmp 0x15d40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: make
static void *make(size_t size, int *error) {
	void *p;

	if (!(p = malloc(size)))
		*error = errno;

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10260
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x15e00
callq 0xf0a0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x104b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
leaq -0x44(%rbp), %rsi
callq 0x156c0
movq -0x38(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0x15f7c
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xd4(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0xc4(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xec(%rbp), %edi
leaq -0xc4(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movl -0xd4(%rbp), %edx
movq -0xd0(%rbp), %rcx
movl -0xc8(%rbp), %r8d
leaq 0x323ff(%rip), %r9      # 0x48367
movq %rax, (%rsp)
movb $0x0, %al
callq 0x14cc0
movl $0x2, -0x4(%rbp)
jmp 0x15fd8
jmp 0x15f7e
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
leaq 0x264(%rip), %rcx       # 0x16200
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x16260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: wakecb_wakeup
static cqs_error_t wakecb_wakeup(struct wakecb *cb) {
	struct cqueue *Q = cb->arg[0];
	struct event *event = cb->arg[1];

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

	return cqueue_tryalert(Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x208, %rsi            # imm = 0x208
addq $0x8, %rsi
callq 0x120f0
movq -0x10(%rbp), %rdi
callq 0x121a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: wakecb_add
static void wakecb_add(struct wakecb *cb, struct condition *cv) {
	if (cv->lifo) {
		TAILQ_INSERT_HEAD(&cv->waiting, cb, tqe);
		cb->cv = cv;
	} else {
		TAILQ_INSERT_TAIL(&cv->waiting, cb, tqe);
		cb->cv = cv;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x162dc
jmp 0x16277
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
je 0x162a3
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x162b3
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16324
jmp 0x162de
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: fileno_update
static int fileno_update(struct cqueue *Q, struct fileno *fileno) {
	struct event *event;
	short events = 0;

	LIST_FOREACH(event, &fileno->events, fle) {
		events |= event->events;
	}

	return fileno_ctl(Q, fileno, events);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x0, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16809
movq -0x18(%rbp), %rax
movswl 0x4(%rax), %ecx
movswl -0x1a(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x167e2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movswl -0x1a(%rbp), %edx
callq 0x11f00
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: err_pushvalue
static const char *err_pushvalue(lua_State *L, struct callinfo *I) {
	if (I->error.value) {
		lua_pushvalue(L, I->error.value);
	} else {
		lua_pushstring(L, "no error message");
	}

	return lua_tostring(L, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x16b0c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xfa50
jmp 0x16b1c
movq -0x8(%rbp), %rdi
leaq 0x3195b(%rip), %rsi     # 0x48472
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0xf130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)