LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: thread_add
static void thread_add(lua_State *L, struct cqueue *Q, struct callinfo *I, int index) {
	struct thread *T;

	index = lua_absindex(L, index);

	T = lua_newuserdata(L, sizeof *T);
	memset(T, 0, sizeof *T);
	TAILQ_INIT(&T->events);
	timer_init(&T->timer);

	/* anchor new lua_State to our thread context */
	lua_pushvalue(L, index);
	cqs_setuservalue(L, -2);
	T->L = lua_tothread(L, index);

	/* anchor thread context to cqueue object */
	cqs_getuservalue(L, I->self);
	lua_pushvalue(L, -2);
	lua_rawsetp(L, -2, CQS_UNIQUE_LIGHTUSERDATA_MASK(T));
	lua_pop(L, 2);

	LIST_INSERT_HEAD(&Q->thread.pending, T, le);
	T->threads = &Q->thread.pending;
	Q->thread.count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf2a0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x68, %esi
callq 0xfbe0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0xf7d0
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x16d80
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xfa50
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x16ab0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf4b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x16a80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfa50
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf180
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x107f0
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
je 0x16d1e
movq -0x28(%rbp), %rcx
addq $0x28, %rcx
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x210(%rax)
movq -0x10(%rbp), %rcx
addq $0x208, %rcx            # imm = 0x208
addq $0x8, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
addq $0x208, %rcx            # imm = 0x208
addq $0x8, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x220(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x220(%rax)
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_checkfd
static int cqueue_checkfd(lua_State *L, struct callinfo *I, int index) {
	int fd;

	if (!lua_isnil(L, index) && !lua_isnumber(L, index)) {
		if (LUA_OK != object_pcall(L, I, NULL, index, "pollfd", LUA_TNUMBER))
			err_error(L, I);

		fd = luaL_optint(L, -1, -1);
		lua_pop(L, 1);
	} else {
		fd = luaL_optint(L, index, -1);
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf280
cmpl $0x0, %eax
je 0x16e3f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xfc70
cmpl $0x0, %eax
jne 0x16e3f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl $0x3, -0x1c(%rbp)
leaq -0x1c(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
leaq 0x313ad(%rip), %r8      # 0x481a3
movl $0x1, (%rsp)
callq 0x15ff0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x16e17
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16e60
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq $-0x1, %rdx
callq 0xf450
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
jmp 0x16e55
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq $-0x1, %rdx
callq 0xf450
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_reboot
static cqs_error_t cqueue_reboot(struct cqueue *Q, _Bool stop, _Bool restart) {
	if (stop) {
		struct fileno *fileno;
		struct thread *thread;

		while ((fileno = LIST_FIRST(&Q->fileno.polling))) {
			LIST_REMOVE(fileno, le);
			LIST_INSERT_HEAD(&Q->fileno.outstanding, fileno, le);
		}

		LIST_FOREACH(fileno, &Q->fileno.outstanding, le) {
			fileno->state = 0;
		}

		while ((thread = LIST_FIRST(&Q->thread.polling))) {
			thread_move(thread, &Q->thread.pending);
		}

		kpoll_destroy(&Q->kp, &cstack_onclosefd, Q->cstack);
	}

	if (restart) {
		int error;

		if ((error = kpoll_init(&Q->kp)))
			return error;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
testb $0x1, -0x11(%rbp)
je 0x16fdc
jmp 0x16eb8
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x16f62
jmp 0x16ed3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x16ef2
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
jmp 0x16f07
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
je 0x16f37
movq -0x20(%rbp), %rcx
addq $0x30, %rcx
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b0(%rax)
movq -0x10(%rbp), %rcx
addq $0x1a0, %rcx            # imm = 0x1A0
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x16eb8
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16f90
movq -0x20(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x16f71
jmp 0x16f92
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x16fc1
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x208, %rsi            # imm = 0x208
addq $0x8, %rsi
callq 0x120f0
jmp 0x16f92
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rdx
leaq 0x89(%rip), %rsi        # 0x17060
callq 0x17010
testb $0x1, -0x12(%rbp)
je 0x16ffd
movq -0x10(%rbp), %rdi
callq 0x17090
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x16ffb
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17004
jmp 0x16ffd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: alert_destroy
static void alert_destroy(struct kpoll *kp, int (*closefd)(int *, void *), void *cb_udata) {
#if ENABLE_PORTS
	(void)kp;
#else
	for (size_t i = 0; i < countof(kp->alert.fd); i++)
		closefd(&kp->alert.fd[i], cb_udata);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0x17131
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
movq -0x20(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x170fc
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: kpoll_preinit
static void kpoll_preinit(struct kpoll *kp) {
	kp->fd = -1;
	kp->pending.count = 0;
	for (size_t i = 0; i < countof(kp->alert.fd); i++)
		kp->alert.fd[i] = -1;
	kp->alert.state = 0;
	kp->alert.pending = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x188(%rax)
movq $0x0, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
jae 0x17191
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0xffffffff, 0x190(%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x17169
movq -0x8(%rbp), %rax
movw $0x0, 0x198(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x19c(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cstack_closefd
static void cstack_closefd(struct cstack *CS, int *fd) {
	/* NB: CS can be NULL. See cqueue_destroy(). */
	if (CS) {
		cstack_cancelfd(CS, *fd);
	}

	cqs_closefd(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x171d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x11080
movq -0x10(%rbp), %rdi
callq 0x171f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.h
// Function: cqs_closefd
static inline void cqs_closefd(int *fd) {
	if (*fd != -1) {
#if __APPLE__
		/* Do we need bother with close$NOCANCEL$UNIX2003? */
		extern int close$NOCANCEL(int);
		close$NOCANCEL(*fd);
#else
		close(*fd);
#endif
		*fd = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x1721a
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x10c10
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: f2ts_
static inline struct timespec *f2ts_(struct timespec *ts, const double f) {
	double s, ns;

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

		ns = modf(f, &s);
		ns = ceil(ns * 1000000000);

		if (ns >= 1000000000) {
			s++;
			ns = 0;
		}

		cqs_static_assert(FLT_RADIX == 2, "FLT_RADIX != 2");
		cqs_static_assert(cqs_ispowerof2((unsigned long)LONG_MAX + 1), "LONG_MAX + 1 not a power of 2");

		if (s >= (unsigned long)LONG_MAX + 1) {
			ts->tv_sec = LONG_MAX;
			ts->tv_nsec = 0;
		} else {
			ts->tv_sec = s;
			ts->tv_nsec = ns;
		}

		return ts;
	case FP_SUBNORMAL:
		ts->tv_sec = 0;
		ts->tv_nsec = 1;

		return ts;
	case FP_ZERO:
		return ts;
	case FP_INFINITE:
	case FP_NAN:
	default:
		return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x2, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl %eax, -0x2c(%rbp)
jne 0x172e4
jp 0x172e4
movl -0x2c(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0x17441
movq -0x40(%rbp), %rax
leaq 0x30d99(%rip), %rcx     # 0x48074
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x38(%rbp), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm0
movl %eax, -0x2c(%rbp)
jp 0x172be
movsd -0x38(%rbp), %xmm0
movaps 0x30d50(%rip), %xmm1    # 0x48050
pand %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x1, %eax
movsd 0x30d02(%rip), %xmm1    # 0x48018
ucomisd %xmm1, %xmm0
movl %eax, -0x2c(%rbp)
jne 0x17323
jp 0x17323
jmp 0x172be
movsd -0x48(%rbp), %xmm1
movsd 0x30cf0(%rip), %xmm0    # 0x48020
movl $0x3, %eax
movl $0x4, %ecx
ucomisd %xmm1, %xmm0
cmovbel %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x172be
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
jge 0x17366
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17449
movsd -0x18(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0x10a00
movsd %xmm0, -0x28(%rbp)
movsd 0x30c8f(%rip), %xmm0    # 0x48010
mulsd -0x28(%rbp), %xmm0
callq 0xf1e0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x30c73(%rip), %xmm1    # 0x48010
ucomisd %xmm1, %xmm0
jb 0x173bd
movsd 0x30c8d(%rip), %xmm0    # 0x48038
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x30c76(%rip), %xmm1    # 0x48040
ucomisd %xmm1, %xmm0
jb 0x173ef
movq -0x10(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x1740a
cvttsd2si -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cvttsd2si -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17449
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17449
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17449
jmp 0x17441
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_destroy
static void cqueue_destroy(lua_State *L, struct cqueue *Q, struct callinfo *I) {
	struct cstack *cstack = Q->cstack;
	struct thread *thread;
	struct fileno *fileno;
	void *next;

	cstack_del(Q);

	Q->thread.current = NULL;

	while ((thread = LIST_FIRST(&Q->thread.pending))) {
		thread_del(L, Q, I, thread);
	}

	while ((thread = LIST_FIRST(&Q->thread.polling))) {
		thread_del(L, Q, I, thread);
	}

	for (fileno = LLRB_MIN(table, &Q->fileno.table); fileno; fileno = next) {
		next = LLRB_NEXT(table, &Q->fileno.table, fileno);
		fileno_del(Q, fileno, 0);
	}

	kpoll_destroy(&Q->kp, &cstack_onclosefd, cstack);

	pool_destroy(&Q->pool.event);
	pool_destroy(&Q->pool.fileno);
	pool_destroy(&Q->pool.wakecb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17590
movq -0x10(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x174c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14b20
jmp 0x1749b
jmp 0x174c9
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x174f5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14b20
jmp 0x174c9
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x17600
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x17536
movq -0x30(%rbp), %rdi
callq 0x17640
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x17700
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x17509
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x4e5(%rip), %rsi      # 0x17060
callq 0x17010
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x30, %rdi
callq 0x177f0
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
callq 0x177f0
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x177f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cstack_del
static void cstack_del(struct cqueue *Q) {
	/* NB: Q->cstack can be NULL. See cqueue_destroy(). */
	if (Q->cstack) {
		LIST_REMOVE(Q, le);
		Q->cstack = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x230(%rax)
je 0x175fb
jmp 0x175a8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x238(%rax)
je 0x175d3
movq -0x8(%rbp), %rax
movq 0x240(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x238(%rax), %rax
movq %rcx, 0x240(%rax)
movq -0x8(%rbp), %rax
movq 0x238(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x240(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x230(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: fileno_del
static int fileno_del(struct cqueue *Q, struct fileno *fileno, _Bool update) {
	struct event *event;
	int error = 0;

	while ((event = LIST_FIRST(&fileno->events))) {
		event->fileno = NULL;
		LIST_REMOVE(event, fle);
	}

	if (update)
		error = fileno_update(Q, fileno);

	LLRB_REMOVE(table, &Q->fileno.table, fileno);

	LIST_REMOVE(fileno, le);

	pool_put(&Q->pool.fileno, fileno);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x17770
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1775b
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, (%rax)
jmp 0x1771e
testb $0x1, -0x11(%rbp)
je 0x17786
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x167c0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
movq -0x10(%rbp), %rsi
callq 0x17840
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x177b9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x14db0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: pool_destroy
static void pool_destroy(struct pool *P) {
	void *p;

	while ((p = P->head)) {
		P->head = *(void **)p;
		free(p);
		P->count--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x17838
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x10060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x177fc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue__gc
static int cqueue__gc(lua_State *L) {
	struct cqueue *Q = cqs_checkudata(L, 1, 1, CQUEUE_CLASS);
	struct callinfo I;

	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 0x30314(%rip), %rcx     # 0x48100
movl %edx, %esi
callq 0x118d0
movq %rax, -0x10(%rbp)
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_create
static int cqueue_create(lua_State *L) {
	struct cqueue *Q;
	int error;

	Q = lua_newuserdata(L, sizeof *Q);

	cqueue_preinit(Q);

	luaL_getmetatable(L, CQUEUE_CLASS);
	lua_setmetatable(L, -2);

	if ((error = cqueue_init(L, Q, -1)))
		goto error;

	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 $0x248, %esi            # imm = 0x248
callq 0xfbe0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18220
movq -0x10(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x30296(%rip), %rdx     # 0x48100
callq 0xf200
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10b10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x182b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x17e99
jmp 0x17ea2
movl $0x1, -0x4(%rbp)
jmp 0x17f0c
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
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_type
static int cqueue_type(lua_State *L) {
	struct cqueue *Q;

	if ((Q = cqs_testudata(L, 1, 1))) {
		if (Q->cstack) {
			lua_pushstring(L, "controller");
		} else {
			lua_pushstring(L, "closed controller");
		}
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11980
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x17f78
movq -0x10(%rbp), %rax
cmpq $0x0, 0x230(%rax)
je 0x17f66
movq -0x8(%rbp), %rdi
leaq 0x305e9(%rip), %rsi     # 0x48548
callq 0xfcc0
jmp 0x17f76
movq -0x8(%rbp), %rdi
leaq 0x305d0(%rip), %rsi     # 0x48541
callq 0xfcc0
jmp 0x17f81
movq -0x8(%rbp), %rdi
callq 0xfa10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cstack_cancel
static int cstack_cancel(lua_State *L) {
	struct callinfo I = CALLINFO_INITIALIZER;
	struct cstack *CS = cstack_self(L);
	int index, fd;

	for (index = 1; index <= lua_gettop(L); index++) {
		fd = cqueue_checkfd(L, &I, index);
		cstack_cancelfd(CS, fd);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x300a9(%rip), %rax     # 0x480ac
movq %rax, -0x20(%rbp)
movq 0x300a6(%rip), %rax     # 0x480b4
movq %rax, -0x18(%rbp)
movq 0x300a3(%rip), %rax     # 0x480bc
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x110d0
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jg 0x18073
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq 0x16da0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x11080
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18031
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cstack_reset
static int cstack_reset(lua_State *L) {
	struct cstack *CS = cstack_self(L);
	struct cqueue *Q;
	int error;

	LIST_FOREACH(Q, &CS->cqueues, le) {
		cqueue_reboot(Q, 1, 0);
	}

	LIST_FOREACH(Q, &CS->cqueues, le) {
		if ((error = cqueue_reboot(Q, 0, 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
callq 0x110d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x180cf
movq -0x20(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x16e90
movq -0x20(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x180a7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1816c
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x16e90
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x18156
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xbc(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xbc(%rbp), %edi
leaq -0xa8(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
leaq 0x3036c(%rip), %rsi     # 0x484b8
movb $0x0, %al
callq 0xfe70
movl %eax, -0x28(%rbp)
jmp 0x18158
movq -0x20(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x180da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cstack_running
static int cstack_running(lua_State *L) {
	struct cstack *CS = cstack_self(L);

	if (CS->running) {
		lua_pushvalue(CS->running->L, CS->running->self);
		lua_xmove(CS->running->L, L, 1);
		lua_pushboolean(L, CS->running->T == L);
	} else {
		lua_pushnil(L);
		lua_pushboolean(L, 0);
	}

	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x110d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x181fd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
callq 0xfa50
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x10380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
jmp 0x18211
movq -0x8(%rbp), %rdi
callq 0xfa10
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_preinit
static void cqueue_preinit(struct cqueue *Q) {
	memset(Q, 0, sizeof *Q);

	kpoll_preinit(&Q->kp);

	Q->thread.current = NULL;

	pool_init(&Q->pool.wakecb, sizeof (struct wakecb));
	pool_init(&Q->pool.fileno, sizeof (struct fileno));
	pool_init(&Q->pool.event, sizeof (struct event));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x248, %edx            # imm = 0x248
callq 0xf7d0
movq -0x8(%rbp), %rdi
callq 0x17140
movq -0x8(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movl $0x38, %esi
callq 0x18330
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
movl $0x40, %esi
callq 0x18330
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x30, %rdi
movl $0x50, %esi
callq 0x18330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_init
static int cqueue_init(lua_State *L, struct cqueue *Q, int index) {
	int error;

	index = lua_absindex(L, index);

	if ((error = kpoll_init(&Q->kp)))
		return error;

	/*
	 * give ourselves an empty table of threads
	 */
	lua_newtable(L);
	cqs_setuservalue(L, index);

	/*
	 * associate ourselves with global continuation stack
	 */
	cstack_add(L, Q);

	return 0;
}

// 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 0xf2a0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17090
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x182eb
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18318
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16ab0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18380
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: dbg_f2ms
static int dbg_f2ms(lua_State *L) {
	int ms = f2ms(luaL_checknumber(L, 1));

	lua_pushinteger(L, ms);
	lua_pushboolean(L, ms == INT_MAX);

	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10b20
callq 0x13a60
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.c
// Function: dbg_f2ts
static int dbg_f2ts(lua_State *L) {
	struct timespec *ts = f2ts(luaL_checknumber(L, 1));

	if (!ts)
		return 0;

	lua_createtable(L, 0, 2);
	lua_pushinteger(L, ts->tv_sec);
	lua_setfield(L, -2, "tv_sec");
	lua_pushinteger(L, ts->tv_nsec);
	lua_setfield(L, -2, "tv_nsec");

	lua_pushboolean(L, ts->tv_sec == LONG_MAX);

	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x10b20
leaq -0x28(%rbp), %rdi
callq 0x17290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x184ca
movl $0x0, -0x4(%rbp)
jmp 0x1854e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10330
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30063(%rip), %rdx     # 0x4855d
callq 0xf580
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x30044(%rip), %rdx     # 0x48564
callq 0xf580
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movl $0x2, -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/socket.c
// Function: cqs_socket_fdopen
lso_error_t cqs_socket_fdopen(lua_State *L, int fd, const struct so_options *_opts) {
	struct so_options opts = *((_opts)? _opts : so_opts());
	struct luasocket *S;
	int type = SOCK_STREAM, error;

	if (0 != getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &(socklen_t){ sizeof type })) {
		switch (errno) {
		case ENOTSOCK:
		case EOPNOTSUPP:
			break;
		default:
			goto syerr;
		}
	}

	S = lso_newsocket(L, type);

	if ((error = lso_prepsocket(S)))
		goto error;

	opts.fd_close.arg = S;
	opts.fd_close.cb = &lso_closefd;

	if (!(S->socket = so_fdopen(fd, &opts, &error)))
		goto error;

	return 0;
syerr:
	error = errno;
error:
	lua_pop(L, 1);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1858a
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x185de
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xf7d0
movb $0x1, -0xaf(%rbp)
movl $0x0, -0xa8(%rbp)
movb $0x1, -0xa4(%rbp)
movb $0x1, -0xa3(%rbp)
movb $0x1, -0xa2(%rbp)
movl $0x1, %eax
movq %rax, -0x80(%rbp)
movb $0x1, -0x78(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movl $0x50, %edx
callq 0xfb40
movl $0x1, -0xcc(%rbp)
movl -0x14(%rbp), %edi
movl $0x4, -0xd4(%rbp)
movl $0x1, %esi
movl $0x3, %edx
leaq -0xcc(%rbp), %rcx
leaq -0xd4(%rbp), %r8
callq 0xfa30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x18656
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0xe4(%rbp)
subl $0x58, %eax
je 0x18650
jmp 0x18643
movl -0xe4(%rbp), %eax
subl $0x5f, %eax
jne 0x18652
jmp 0x18650
jmp 0x18654
jmp 0x186cd
jmp 0x18656
movq -0x10(%rbp), %rdi
movl -0xcc(%rbp), %esi
callq 0x18700
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x18840
movl %eax, -0xd0(%rbp)
cmpl $0x0, %eax
je 0x18685
jmp 0x186da
movq -0xc8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x1c9(%rip), %rax       # 0x18860
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %edi
leaq -0x70(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0xf330
movq -0xc8(%rbp), %rcx
movq %rax, 0x128(%rcx)
cmpq $0x0, %rax
jne 0x186c4
jmp 0x186da
movl $0x0, -0x4(%rbp)
jmp 0x186f1
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movl -0xd0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_newsocket
static struct luasocket *lso_newsocket(lua_State *L, int type) {
	struct luasocket *S;

	S = lua_newuserdata(L, sizeof *S);
	*S = *lso_prototype(L);

	S->type = type;

	fifo_init(&S->ibuf.fifo);
	fifo_init(&S->obuf.fifo);

	if (S->onerror != LUA_NOREF && S->onerror != LUA_REFNIL) {
		cqs_getref(L, S->onerror);
		S->onerror = LUA_NOREF;
		cqs_ref(L, &S->onerror);
	}

#if defined LUA_RIDX_MAINTHREAD
	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
	S->mainthread = lua_tothread(L, -1);
	lua_pop(L, 1);
#endif

	luaL_getmetatable(L, LSO_CLASS);
	lua_setmetatable(L, -2);

	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x148, %esi            # imm = 0x148
callq 0xfbe0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18ef0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl $0x148, %edx            # imm = 0x148
callq 0xfb40
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x120(%rax)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x18f20
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x18f20
movq -0x18(%rbp), %rax
cmpl $-0x2, 0x130(%rax)
je 0x187d2
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x130(%rax)
je 0x187d2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x130(%rax), %esi
callq 0x18fb0
movq -0x18(%rbp), %rax
movl $0xfffffffe, 0x130(%rax) # imm = 0xFFFFFFFE
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x18ff0
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x1, %edx
callq 0xf4a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf4b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x2f8f4(%rip), %rdx     # 0x48113
callq 0xf200
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10b10
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_closefd
static int lso_closefd(int *fd, void *arg) {
	struct luasocket *S = arg;

	if (S->mainthread) {
		cqs_cancelfd(S->mainthread, *fd);
		cqs_closefd(fd);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0x188a5
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0xfd10
movq -0x8(%rbp), %rdi
callq 0x194f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: luaopen__cqueues_socket
lso_nargs_t luaopen__cqueues_socket(lua_State *L) {
	static const struct cqs_macro macros[] = {
		{ "AF_UNSPEC",      AF_UNSPEC },
		{ "AF_INET",        AF_INET },
		{ "AF_INET6",       AF_INET6 },
		{ "AF_UNIX",        AF_UNIX },
		{ "SOCK_STREAM",    SOCK_STREAM },
		{ "SOCK_SEQPACKET", SOCK_SEQPACKET },
		{ "SOCK_DGRAM",     SOCK_DGRAM },
	};

	cqs_pushnils(L, LSO_UPVALUES); /* initial upvalues */
	cqs_newmetatable(L, LSO_CLASS, lso_methods, lso_metamethods, LSO_UPVALUES);
	lua_pushvalue(L, -1); /* push self as replacement upvalue */
	cqs_setmetaupvalue(L, -2, LSO_INDEX); /* insert self as upvalue */

	luaL_newlibtable(L, lso_globals);
	cqs_pushnils(L, LSO_UPVALUES); /* initial upvalues */
	luaL_setfuncs(L, lso_globals, LSO_UPVALUES);
	lua_pushvalue(L, -2); /* push metatable */
	cqs_setfuncsupvalue(L, -2, LSO_INDEX);

	cqs_setmacros(L, -1, macros, countof(macros), 0);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x18af0
movq -0x8(%rbp), %rdi
leaq 0x2f6de(%rip), %rsi     # 0x48113
leaq 0x44464(%rip), %rdx     # 0x5cea0
leaq 0x446cd(%rip), %rcx     # 0x5d110
movl $0x1, %r8d
callq 0x18b40
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xfa50
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x18c60
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x18af0
movq -0x8(%rbp), %rdi
leaq 0x44698(%rip), %rsi     # 0x5d130
movl $0x1, %edx
callq 0x10390
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfa50
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x18d00
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x4092d(%rip), %rdx     # 0x59400
movl $0x7, %ecx
xorl %r8d, %r8d
callq 0x18da0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.h
// Function: cqs_setmacros
static inline void cqs_setmacros(lua_State *L, int index, const struct cqs_macro *macro, size_t count, _Bool swap) {
	index = lua_absindex(L, index);

	for (unsigned i = 0; i < count; i++) {
		lua_pushstring(L, macro[i].name);
		lua_pushinteger(L, macro[i].value);
		lua_rawset(L, index);
	}

	if (!swap)
		return;

	for (unsigned i = 0; i < count; i++) {
		lua_pushinteger(L, macro[i].value);
		lua_pushstring(L, macro[i].name);
		lua_rawset(L, index);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xf2a0
movl %eax, -0xc(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x18e2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xfae0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x18dd5
testb $0x1, -0x21(%rbp)
jne 0x18e32
jmp 0x18e8e
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x18e8e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xfae0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18e39
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_init
static struct fifo *fifo_init(struct fifo *fifo, void *buf, size_t size) {
	fifo->sbuf  = (struct iovec){ buf, size };
	fifo->base  = fifo->sbuf.iov_base;
	fifo->size  = fifo->sbuf.iov_len;
	fifo->head  = 0;
	fifo->count = 0;
	fifo->rbits.byte  = 0;
	fifo->rbits.count = 0;
	fifo->wbits.byte  = 0;
	fifo->wbits.count = 0;

	return fifo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x31(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x32(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x33(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.h
// Function: cqs_getref
static inline void cqs_getref(lua_State *L, cqs_ref_t ref) {
	if (ref != LUA_NOREF)
		lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
	else
		lua_pushnil(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x2, -0xc(%rbp)
je 0x18fd9
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf4a0
jmp 0x18fe2
movq -0x8(%rbp), %rdi
callq 0xfa10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_singleton
static void *lso_singleton(lua_State *L, const void *key, const void *init, size_t len) {
	void *p;

	lua_rawgetp(L, LUA_REGISTRYINDEX, key);
	p = lua_touserdata(L, -1);
	lua_pop(L, 1);

	if (p)
		return p;

	p = lua_newuserdata(L, len);
	if (init)
		memcpy(p, init, len);
	else
		memset(p, 0, len);
	lua_rawsetp(L, LUA_REGISTRYINDEX, key);

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf070
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x104b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
cmpq $0x0, -0x30(%rbp)
je 0x1908b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x190df
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xfbe0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x190b6
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xfb40
jmp 0x190c5
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0xf7d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf180
movq -0x30(%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/socket.c
// Function: lso_adjbufs
static lso_error_t lso_adjbufs(struct luasocket *S) {
	int error;

	if ((error = lso_adjbuf(&S->ibuf.fifo, S->ibuf.bufsiz)))
		return error;

	if ((error = lso_adjbuf(&S->obuf.fifo, S->obuf.bufsiz)))
		return error;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x191b0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x19165
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1919b
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0x191b0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x19194
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1919b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_realloc
static int fifo_realloc(struct fifo *fifo, size_t size) {
	void *tmp;

	if (fifo->size >= size)
		return 0;
	if (fifo_type(fifo) == FIFO_STATIC)
		return ENOMEM;

	fifo_realign(fifo);

	size = fifo_roundup(size);

	if (!(tmp = realloc(fifo->base, size)))
		return errno;

	fifo->base = tmp;
	fifo->size = size;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x19217
movl $0x0, -0x4(%rbp)
jmp 0x1928a
movq -0x10(%rbp), %rdi
callq 0x192a0
cmpl $0x1, %eax
jne 0x1922e
movl $0xc, -0x4(%rbp)
jmp 0x1928a
movq -0x10(%rbp), %rdi
callq 0x192d0
movq -0x18(%rbp), %rdi
callq 0x19420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x107d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1926b
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1928a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_realign
static void fifo_realign(struct fifo *fifo) {
	if (fifo->size - fifo->head >= fifo->count) {
		memmove(fifo->base, &fifo->base[fifo->head], fifo->count);
		fifo->head = 0;
	} else {
		unsigned char tmp[FIFO_TMPBUFSIZ];
		unsigned n, m;

		while (fifo->head != 0) {
			n = FIFO_MIN(fifo->head, sizeof tmp);
			m = fifo->size - n;

			memcpy(tmp, fifo->base, n);
			memmove(fifo->base, &fifo->base[n], m);
			memcpy(&fifo->base[m], tmp, n);
			fifo->head -= n;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1932f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x107a0
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x19416
jmp 0x19331
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19414
movq -0x8(%rbp), %rax
cmpq $0x800, 0x20(%rax)      # imm = 0x800
jae 0x1935f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x820(%rbp)
jmp 0x1936d
movl $0x800, %eax            # imm = 0x800
movq %rax, -0x820(%rbp)
jmp 0x1936d
movq -0x820(%rbp), %rax
movl %eax, -0x814(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x814(%rbp), %ecx
subq %rcx, %rax
movl %eax, -0x818(%rbp)
leaq -0x810(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x814(%rbp), %eax
movl %eax, %edx
callq 0xfb40
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x814(%rbp), %eax
addq %rax, %rsi
movl -0x818(%rbp), %eax
movl %eax, %edx
callq 0x107a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x818(%rbp), %eax
addq %rax, %rdi
leaq -0x810(%rbp), %rsi
movl -0x814(%rbp), %eax
movl %eax, %edx
callq 0xfb40
movl -0x814(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
jmp 0x19331
jmp 0x19416
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_roundup
static inline size_t fifo_roundup(size_t i) {
	if (i > ~(((size_t)-1) >> 1u))
		return (size_t)-1;
	else
		return fifo_power2(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jbe 0x19446
movq $-0x1, -0x8(%rbp)
jmp 0x19453
movq -0x10(%rbp), %rdi
callq 0x19460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_power2
static inline size_t fifo_power2(size_t i) {
#if defined SIZE_MAX
	i--;
	i |= i >> 1;
	i |= i >> 2;
	i |= i >> 4;
	i |= i >> 8;
	i |= i >> 16;
#if SIZE_MAX != 0xffffffffu
	i |= i >> 32;
#endif
	return ++i;
#else
#error No SIZE_MAX defined
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)