LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_timeout
static int lsl_timeout(lua_State *L) {
	struct signalfd *S = luaL_checkudata(L, 1, LSL_CLASS);
	sigset_t none;

	sigemptyset(&none);

	if (sfd_diff(&S->pending, &none)) {
		lua_pushnumber(L, 0.0);
	} else if (isnormal(S->timeout) && !signbit(S->timeout)) {
		lua_pushnumber(L, S->timeout);
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x168f4(%rip), %rdx     # 0x30e5d
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x100a0
leaq 0x108(%r14), %rdi
movq %r15, %rsi
callq 0x1a65b
testl %eax, %eax
je 0x1a598
pxor %xmm0, %xmm0
jmp 0x1a5dc
movq 0x188(%r14), %xmm0
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setae %cl
testq %rax, %rax
sets %al
orb %cl, %al
je 0x1a5dc
movq %rbx, %rdi
callq 0xf9d0
jmp 0x1a5e4
movq %rbx, %rdi
callq 0xf2d0
pushq $0x1
popq %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_settimeout
static int lsl_settimeout(lua_State *L) {
	struct signalfd *S = luaL_checkudata(L, 1, LSL_CLASS);

	lua_settop(L, 2);

	lua_pushnumber(L, S->timeout);

	S->timeout = luaL_optnumber(L, 2, NAN);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x16858(%rip), %rdx     # 0x30e5d
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xfd80
movq %rax, %r14
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x106f0
movsd 0x188(%r14), %xmm0
movq %rbx, %rdi
callq 0xf2d0
movsd 0x159ce(%rip), %xmm0    # 0x30008
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf7c0
movsd %xmm0, 0x188(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: sfd_diff
static int sfd_diff(const sigset_t *a, const sigset_t *b) {
	for (int signo = 1; signo < 32; signo++) {
		if (!!sigismember(a, signo) ^ !!sigismember(b, signo))
			return signo;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbx
cmpl $0x20, %ebx
je 0x1a698
movq %r15, %rdi
movl %ebx, %esi
callq 0xf650
testl %eax, %eax
setne %bpl
movq %r14, %rdi
movl %ebx, %esi
callq 0xf650
testl %eax, %eax
setne %al
xorb %bpl, %al
jne 0x1a69a
incl %ebx
jmp 0x1a66b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_listen
static int lsl_listen(lua_State *L) {
	struct signalfd *S;
	int index, error;

	S = lua_newuserdata(L, sizeof *S);

	sfd_preinit(S);

	for (index = 1; index <= lua_gettop(L) - 1; index++)
		sigaddset(&S->desired, luaL_checkint(L, index));

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

	if ((error = sfd_init(S)) || (error = sfd_update(S)))
		return luaL_error(L, "signal.listen: %s", cqs_strerror(error));

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x190, %esi            # imm = 0x190
callq 0xfb70
movq %rax, %r14
movq %rax, %r12
movq %rax, %rdi
callq 0x1a387
leaq 0x8(%r14), %r15
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jge 0x1a6fc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movq %r15, %rdi
movl %eax, %esi
callq 0x10570
incl %ebp
jmp 0x1a6d8
leaq 0x1675a(%rip), %rdx     # 0x30e5d
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf1f0
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x109f0
orb $0x1, (%r12)
pushq $-0x1
popq %rdi
movq %r15, %rsi
movl $0x80800, %edx          # imm = 0x80800
callq 0xf7a0
movl %eax, 0x4(%r12)
cmpl $-0x1, %eax
je 0x1a785
leaq 0x88(%r14), %rdi
pushq $0x10
popq %rcx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x88, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a65b
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x1a7e2
movl 0x4(%r12), %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf7a0
cmpl $-0x1, %eax
je 0x1a792
pushq $0x10
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x1a7e2
callq 0xf0a0
movl (%rax), %edi
testl %edi, %edi
jne 0x1a79d
jmp 0x1a74a
callq 0xf0a0
movl (%rax), %edi
testl %edi, %edi
je 0x1a7e2
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
callq 0xf260
leaq 0x166ed(%rip), %rsi     # 0x30ec0
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_type
static int lsl_type(lua_State *L) {
	if (luaL_testudata(L, 1, LSL_CLASS)) {
		lua_pushstring(L, "signal listener");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1665e(%rip), %rdx     # 0x30e5d
pushq $0x1
popq %rsi
callq 0x107e0
testq %rax, %rax
je 0x1a81d
leaq 0x166bf(%rip), %rsi     # 0x30ed2
movq %rbx, %rdi
callq 0xfc50
jmp 0x1a825
movq %rbx, %rdi
callq 0xf9d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_strflag
static int lsl_strflag(lua_State *L) {
	int top = lua_gettop(L), count = 0;

	for (int i = 1; i <= top; i++) {
		int flags = luaL_checkint(L, i);
		int flag;

		while ((flag = signal_flags(&flags))) {
			const char *txt;

			if ((txt = signal_strflag(flag))) {
				luaL_checkstack(L, 1, "too many results");
				lua_pushstring(L, txt);
				count++;
			}
		}
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf970
xorl %ebp, %ebp
testl %eax, %eax
cmovlel %ebp, %eax
incl %eax
movl %eax, (%rsp)
pushq $0x1
popq %r15
leaq 0x4(%rsp), %r12
leaq 0x2849e(%rip), %r14     # 0x42d70
cmpl (%rsp), %r15d
je 0x1a925
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10b40
movl %eax, 0x4(%rsp)
movq %r12, %rdi
callq 0x1addd
testl %eax, %eax
je 0x1a920
bsfl %eax, %eax
movq (%r14,%rax,8), %r13
testq %r13, %r13
je 0x1a8e7
movq %rbx, %rdi
pushq $0x1
popq %rsi
leaq 0x165d6(%rip), %rdx     # 0x30ee2
callq 0xfd30
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfc50
incl %ebp
jmp 0x1a8e7
incl %r15d
jmp 0x1a8d2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_flags
static int lsl_flags(lua_State *L) {
	int i, flags = 0;

	for (i = 1; i <= lua_gettop(L); i++)
		flags |= luaL_checkint(L, i);

	lua_pushinteger(L, flags);
	lua_pushcclosure(L, &lsl_nxtflag, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1a960
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
orl %eax, %r14d
incl %ebp
jmp 0x1a943
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf960
leaq 0x498(%rip), %rsi       # 0x1ae0a
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x10ad0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_ignore
static int ls_ignore(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = SIG_IGN;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.ignore: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1aa3b
movq $0x1, 0x8(%rsp)
movq %r14, %rdi
callq 0x100a0
andl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movl %eax, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x100b0
incl %ebp
testl %eax, %eax
je 0x1a9a3
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf260
leaq 0x164ee(%rip), %rsi     # 0x30f18
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1aa48
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_default
static int ls_default(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = SIG_DFL;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.default: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1ab0a
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
callq 0x100a0
andl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movl %eax, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x100b0
incl %ebp
testl %eax, %eax
je 0x1aa75
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf260
leaq 0x16431(%rip), %rsi     # 0x30f2a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1ab17
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_discard
static int ls_discard(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = &ls_noop;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.discard: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r14
leaq 0x331(%rip), %r12       # 0x1ae79
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1abe1
movq %r12, 0x8(%rsp)
movq %r14, %rdi
callq 0x100a0
andl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movl %eax, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x100b0
incl %ebp
testl %eax, %eax
je 0x1ab4d
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf260
leaq 0x1636d(%rip), %rsi     # 0x30f3d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1abee
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_block
static int ls_block(lua_State *L) {
	sigset_t set;
	int index, error;

	sigemptyset(&set);

	for (index = 1; index <= lua_gettop(L); index++) {
		sigaddset(&set, luaL_checkint(L, index));
	}

	if ((error = cqs_sigmask(SIG_BLOCK, &set, 0)))
		return luaL_error(L, "signal.block: %s", cqs_strerror(error));

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x100a0
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1ac40
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movq %r14, %rdi
movl %eax, %esi
callq 0x10570
incl %ebp
jmp 0x1ac1c
movq %rsp, %rsi
xorl %edi, %edi
xorl %edx, %edx
callq 0x105c0
testl %eax, %eax
je 0x1ac9e
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf260
leaq 0x162c3(%rip), %rsi     # 0x30f50
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1acab
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_unblock
static int ls_unblock(lua_State *L) {
	sigset_t set;
	int index, error;

	sigemptyset(&set);

	for (index = 1; index <= lua_gettop(L); index++) {
		sigaddset(&set, luaL_checkint(L, index));
	}

	if ((error = cqs_sigmask(SIG_UNBLOCK, &set, 0)))
		return luaL_error(L, "signal.unblock: %s", cqs_strerror(error));

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x100a0
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1acf9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movq %r14, %rdi
movl %eax, %esi
callq 0x10570
incl %ebp
jmp 0x1acd5
pushq $0x1
popq %rbp
movq %rsp, %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x105c0
testl %eax, %eax
je 0x1ad5a
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf260
leaq 0x16218(%rip), %rsi     # 0x30f61
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1ad64
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: ls_raise
static int ls_raise(lua_State *L) {
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		raise(luaL_checkint(L, index));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1ad9c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movl %eax, %edi
callq 0xfdc0
incl %ebp
jmp 0x1ad7b
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: signal_flags
static int signal_flags(int *flags) {
	while (0xFFFFFFFF & *flags) {
		int flag = 1 << (ffs(0xFFFFFFFF & *flags) - 1);
		*flags &= ~flag;
		if (signal_strflag(flag))
			return flag;
	}

	return 0;
}

// Assembly:
movl (%rdi), %edx
leaq 0x27f8a(%rip), %rcx     # 0x42d70
testl %edx, %edx
je 0x1ae07
movl %edx, %esi
movl %edx, %eax
negl %eax
andl %edx, %eax
movl %eax, %edx
xorl %esi, %edx
movl %edx, (%rdi)
testl %eax, %eax
je 0x1ade6
bsfl %esi, %esi
cmpq $0x0, (%rcx,%rsi,8)
je 0x1ade6
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/signal.c
// Function: lsl_nxtflag
static int lsl_nxtflag(lua_State *L) {
	int flags = (int)lua_tointeger(L, lua_upvalueindex(1));
	int flag;

	if ((flag = signal_flags(&flags))) {
		lua_pushinteger(L, flags);
		lua_replace(L, lua_upvalueindex(1));

		lua_pushinteger(L, flag);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %edx, %edx
callq 0xfdb0
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
callq 0x1addd
testl %eax, %eax
je 0x1ae6d
movl %eax, %ebp
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xf960
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfd50
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x106f0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: luaopen__cqueues_thread
int luaopen__cqueues_thread(lua_State *L) {
	int error;

	if ((error = ct_protectssl())) {
		if (error == -1) {
			return luaL_error(L, "%s", dlerror());
		} else {
			return luaL_error(L, "%s", cqs_strerror(error));
		}
	}

	cqs_newmetatable(L, CQS_THREAD, ct_methods, ct_metamethods, 0);

	luaL_newlib(L, ct_globals);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x2b7d5(%rip), %rdi     # 0x46668
callq 0x10450
cmpq $0x0, 0x2b7f0(%rip)     # 0x46690
je 0x1aebd
cmpq $0x0, 0x2b7ee(%rip)     # 0x46698
je 0x1aefa
leaq 0x2b7b5(%rip), %rdi     # 0x46668
callq 0xfa00
jmp 0x1af59
pushq $0x28
popq %rdi
callq 0x101a0
movq %rax, 0x2b7c4(%rip)     # 0x46690
testq %rax, %rax
je 0x1af2a
movb $0x1, %r15b
xorl %eax, %eax
pushq $0x1
popq %r14
testb $0x1, %r15b
je 0x1aea2
imulq $0x28, %rax, %rdi
addq 0x2b7a5(%rip), %rdi     # 0x46690
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x104a0
movq %r14, %rax
jmp 0x1aeda
movq 0x2a0df(%rip), %rdi     # 0x44fe0
movq %rsp, %rsi
callq 0xf600
testl %eax, %eax
je 0x1af33
movq (%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x102b0
movq %rax, 0x2b778(%rip)     # 0x46698
xorl %ebp, %ebp
cmpq $0x1, %rax
sbbl %ebp, %ebp
jmp 0x1af36
callq 0xf0a0
movl (%rax), %ebp
jmp 0x1af36
pushq $-0x1
popq %rbp
leaq 0x2b72b(%rip), %rdi     # 0x46668
callq 0xfa00
testl %ebp, %ebp
je 0x1af59
cmpl $-0x1, %ebp
jne 0x1afe2
callq 0xfcd0
jmp 0x1b015
leaq 0x1604c(%rip), %rsi     # 0x30fac
movq %rbx, %rdi
callq 0x10210
leaq 0x27f51(%rip), %rsi     # 0x42ec0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x4
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10270
leaq 0x27ee1(%rip), %rsi     # 0x42e70
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
leaq 0x15187(%rip), %rdx     # 0x30127
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xf550
movsd 0x1504d(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10270
leaq 0x27f1d(%rip), %rsi     # 0x42ef0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x1
popq %rax
jmp 0x1b029
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf260
leaq 0x15f31(%rip), %rsi     # 0x30f4d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: ct_join
static int ct_join(lua_State *L) {
	struct cthread *ct = ct_checkthread(L, 1);
	int error;

	if (pthread_equal(ct->id, pthread_self()))
		return luaL_error(L, "thread.join: cannot join self");

	if (0 == read(ct->pipe[0], &(char){ 0 }, 1)) {
		lua_pushboolean(L, 1);

		if (ct->error)
			lua_pushinteger(L, ct->error);
		else if (ct->msg)
			lua_pushstring(L, ct->msg);
		else
			lua_pushnil(L);

		return 2;
	} else {
		error = errno;

		if (error == EAGAIN && !hdl_isheld(&ct->handle))
			error = CT_EOWNERDEAD;

		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b16d
movq %rax, %r14
movq 0x18(%rax), %r15
callq 0xfc10
movq %r15, %rdi
movq %rax, %rsi
callq 0x10860
testl %eax, %eax
je 0x1b07c
leaq 0x15f54(%rip), %rsi     # 0x30fbc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfdf0
movl 0x1a8(%r14), %edi
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
pushq $0x1
popq %rdx
callq 0x103b0
testq %rax, %rax
je 0x1b0d5
callq 0xf0a0
movl (%rax), %ebp
cmpl $0xb, %ebp
jne 0x1b0ff
addq $0x180, %r14            # imm = 0x180
movq %r14, %rdi
callq 0xf200
testl %eax, %eax
je 0x1b0c6
cmpl $0x82, %eax
jne 0x1b0fc
movq %r14, %rdi
callq 0xfba0
movq %r14, %rdi
callq 0xfa00
movl $0x82, %ebp
jmp 0x1b0ff
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x108d0
movslq 0x4(%r14), %rsi
testq %rsi, %rsi
jne 0x1b10c
movq 0x10(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0x1b122
callq 0xfc50
jmp 0x1b114
pushq $0xb
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xf9d0
jmp 0x1b114
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: ct__eq
static int ct__eq(lua_State *L) {
	struct cthread **a = luaL_testudata(L, 1, CQS_THREAD);
	struct cthread **b = luaL_testudata(L, 2, CQS_THREAD);

	lua_pushboolean(L, a && b && (*a == *b));

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x15df2(%rip), %r15     # 0x30fac
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x107e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x107e0
testq %r14, %r14
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
xorl %esi, %esi
cmpb $0x1, %dl
jne 0x1b1f7
movq (%r14), %rcx
xorl %esi, %esi
cmpq (%rax), %rcx
sete %sil
movq %rbx, %rdi
callq 0x108d0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: ct__gc
static int ct__gc(lua_State *L) {
	struct cthread **ud = luaL_checkudata(L, 1, CQS_THREAD);

	ct_release(*ud);
	*ud = NULL;

	return 0;
}

// Assembly:
pushq %rbx
leaq 0x15d9c(%rip), %rdx     # 0x30fac
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, %rbx
movq (%rax), %rdi
callq 0x1b22b
andq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: ct_type
static int ct_type(lua_State *L) {
	if (luaL_testudata(L, 1, CQS_THREAD)) {
		lua_pushstring(L, "thread");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x15200(%rip), %rdx     # 0x30fac
pushq $0x1
popq %rsi
callq 0x107e0
testq %rax, %rax
je 0x1bdca
leaq 0x1529c(%rip), %rsi     # 0x3105c
movq %rbx, %rdi
callq 0xfc50
jmp 0x1bdd2
movq %rbx, %rdi
callq 0xf9d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/thread.c
// Function: atpanic_trap
static int atpanic_trap(lua_State *L NOTUSED) {
	struct cthread *ct;

	if ((ct = pthread_getspecific(atpanic.key)))
		_longjmp(ct->trap, EINVAL);

	return 0;
}

// Assembly:
pushq %rax
movl 0x2a3ec(%rip), %edi     # 0x4665c
callq 0x10520
testq %rax, %rax
jne 0x1c27e
xorl %eax, %eax
popq %rcx
retq
addq $0xb0, %rax
pushq $0x16
popq %rsi
movq %rax, %rdi
callq 0x100c0
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: luaopen__cqueues_notify
int luaopen__cqueues_notify(lua_State *L) {
	static const struct {
		const char *name;
		int value;
	} flag[] = {
		{ "CREATE", NOTIFY_CREATE },
		{ "DELETE", NOTIFY_DELETE },
		{ "ATTRIB", NOTIFY_ATTRIB },
		{ "MODIFY", NOTIFY_MODIFY },
		{ "REVOKE", NOTIFY_REVOKE },
		{ "ALL",    NOTIFY_ALL },

		{ "INOTIFY",    NOTIFY_INOTIFY },
		{ "FEN",        NOTIFY_FEN },
		{ "KQUEUE",     NOTIFY_KQUEUE },
		{ "KQUEUE1",    NOTIFY_KQUEUE1 },
		{ "OPENAT",     NOTIFY_OPENAT },
		{ "FDOPENDIR",  NOTIFY_FDOPENDIR},
		{ "O_CLOEXEC",  NOTIFY_O_CLOEXEC },
		{ "IN_CLOEXEC", NOTIFY_IN_CLOEXEC },
	};
	unsigned i;

	if (luaL_newmetatable(L, CQS_NOTIFY)) {
		luaL_setfuncs(L, ln_metatable, 0);

		luaL_newlib(L, ln_methods);
		lua_setfield(L, -2, "__index");
	}

	luaL_newlib(L, ln_globals);

	for (i = 0; i < countof(flag); i++) {
		lua_pushinteger(L, flag[i].value);
		lua_setfield(L, -2, flag[i].name);

		lua_pushinteger(L, flag[i].value);
		lua_pushstring(L, flag[i].name);
		lua_settable(L, -3);
	}

	lua_pushinteger(L, notify_features());
	lua_setfield(L, -2, "FEATURES");

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x14d9f(%rip), %rsi     # 0x310cc
callq 0x10210
testl %eax, %eax
je 0x1c38c
leaq 0x26ce3(%rip), %rsi     # 0x43020
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
movsd 0x13cb1(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x6
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x26cd0(%rip), %rsi     # 0x43040
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
leaq 0x13da6(%rip), %rdx     # 0x30127
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xf550
movsd 0x13c6c(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x5
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x26cfb(%rip), %rsi     # 0x430b0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x8
popq %r13
leaq 0x26b76(%rip), %rbp     # 0x42f40
pushq $-0x3
popq %r14
cmpq $0xe8, %r13
je 0x1c421
movslq (%r13,%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf960
movq -0x8(%r13,%rbp), %r12
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movq %r12, %rdx
callq 0xf550
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf960
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfc50
movq %rbx, %rdi
movl %r14d, %esi
callq 0x102f0
addq $0x10, %r13
jmp 0x1c3ce
callq 0xf830
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf960
leaq 0x14a30(%rip), %rdx     # 0x30e68
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0xf550
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln__gc
static int ln__gc(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);

	notify_close(N->notify);
	N->notify = 0;

	return 0;
}

// Assembly:
pushq %rbx
leaq 0x14c6f(%rip), %rdx     # 0x310cc
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, %rbx
movq (%rax), %rdi
callq 0x10750
andq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_step
static int ln_step(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	int error;

	if ((error = notify_step(N->notify, 0))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	} else {
		lua_pushboolean(L, 1);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x14c46(%rip), %rdx     # 0x310cc
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xfd80
movq (%rax), %rdi
xorl %esi, %esi
callq 0xfbb0
testl %eax, %eax
je 0x1c4bb
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x2
popq %rbp
jmp 0x1c4c5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_get
static int ln_get(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	const char *name = 0;
	int changes;

	if (!(changes = notify_get(N->notify, &name)))
		return 0;

	lua_pushinteger(L, changes);
	lua_pushstring(L, name);

	return 2;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x14bf1(%rip), %rdx     # 0x310cc
pushq $0x1
popq %rsi
callq 0xfd80
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq (%rax), %rdi
callq 0x108b0
testl %eax, %eax
je 0x1c515
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf960
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xfc50
pushq $0x2
popq %rax
jmp 0x1c517
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_add
static int ln_add(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	const char *name = luaL_checkstring(L, 2);
	int flags = luaL_optinteger(L, 3, NOTIFY_ALL);
	int error;

	if ((error = notify_add(N->notify, name, flags))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	} else {
		lua_pushboolean(L, 1);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x14b9d(%rip), %rdx     # 0x310cc
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0xfd80
movq %rax, %r15
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xf660
movq %rax, %r12
pushq $0x3
popq %rsi
pushq $0x1f
popq %rdx
movq %rbx, %rdi
callq 0xf420
movq (%r15), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xf240
testl %eax, %eax
je 0x1c589
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0xf960
jmp 0x1c597
movq %rbx, %rdi
movl %r14d, %esi
callq 0x108d0
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_timeout
static int ln_timeout(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	int timeout;

	if ((timeout = notify_timeout(N->notify)) >= 0) {
		lua_pushnumber(L, (lua_Number)timeout / 1000);

		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x14aba(%rip), %rdx     # 0x310cc
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0xfd80
movq (%rax), %rdi
callq 0xf150
testl %eax, %eax
js 0x1c63e
cvtsi2sd %eax, %xmm0
divsd 0x139e4(%rip), %xmm0    # 0x30018
movq %r14, %rdi
callq 0xf2d0
jmp 0x1c640
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_opendir
static int ln_opendir(lua_State *L) {
	const char *path = luaL_checkstring(L, 1);
	struct luanotify *N = 0;
	int error;

	N = lua_newuserdata(L, sizeof *N);
	N->notify = 0;
	luaL_setmetatable(L, CQS_NOTIFY);

	if (!(N->notify = notify_opendir(path, NOTIFY_ALL, &error)))
		goto error;

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

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0xf660
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0xfb70
movq %rax, %r15
andq $0x0, (%rax)
leaq 0x14a50(%rip), %rsi     # 0x310cc
movq %rbx, %rdi
callq 0x10280
pushq $0x1f
popq %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0xf690
movq %rax, (%r15)
testq %rax, %rax
jne 0x1c6b4
movq %rbx, %rdi
callq 0xf9d0
movslq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_type
static int ln_type(lua_State *L) {
	if (luaL_testudata(L, 1, CQS_NOTIFY)) {
		lua_pushstring(L, "file notifier");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14a00(%rip), %rdx     # 0x310cc
pushq $0x1
popq %rsi
callq 0x107e0
testq %rax, %rax
je 0x1c6ea
leaq 0x149fb(%rip), %rsi     # 0x310db
movq %rbx, %rdi
callq 0xfc50
jmp 0x1c6f2
movq %rbx, %rdi
callq 0xf9d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_strflag
static int ln_strflag(lua_State *L) {
	int flags = luaL_checkint(L, 1);
	int flag, count = 0;
	const char *name;

	while (ffs(flags)) {
		flag = 1 << (ffs(flags) - 1);
		flags &= ~flag;

		if ((name = notify_strflag(flag))) {
			luaL_checkstack(L, 1, "too many results");
			lua_pushstring(L, name);
			count++;
		}
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x10b40
movq %rax, %r14
xorl %r15d, %r15d
leaq 0x1474d(%rip), %r12     # 0x30ee2
testl %r14d, %r14d
je 0x1c7cf
movl %r14d, %edi
negl %edi
andl %r14d, %edi
xorl %edi, %r14d
callq 0xfda0
testq %rax, %rax
je 0x1c795
movq %rax, %r13
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xfd30
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfc50
incl %r15d
jmp 0x1c795
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_flags
static int ln_flags(lua_State *L) {
	int i, flags = 0;

	for (i = 1; i <= lua_gettop(L); i++)
		flags |= luaL_checkint(L, i);

	lua_pushinteger(L, flags);
	lua_pushcclosure(L, &ln_nxtflag, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0xf970
cmpl %eax, %ebp
jg 0x1c80b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
orl %eax, %r14d
incl %ebp
jmp 0x1c7ee
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf960
leaq 0x14(%rip), %rsi        # 0x1c831
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x10ad0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/notify.c
// Function: ln_nxtflag
static int ln_nxtflag(lua_State *L) {
	int flags = (int)lua_tointeger(L, lua_upvalueindex(1));
	int flag;

	if (ffs(flags)) {
		flag = 1 << (ffs(flags) - 1);

		lua_pushinteger(L, flags & ~flag);
		lua_replace(L, lua_upvalueindex(1));

		lua_pushinteger(L, flag);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %edx, %edx
callq 0xfdb0
testl %eax, %eax
je 0x1c888
movl %eax, %ebp
negl %ebp
andl %eax, %ebp
xorl %ebp, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf960
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfd50
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x106f0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $-0x1
popq %rsi
callq 0xf290
movl %eax, %ebp
xorl %eax, %eax
movl %eax, %r12d
cmpq %rbx, %r12
jae 0x1cb90
movq %r12, %r13
shlq $0x4, %r13
movq (%r14,%r13), %rsi
movq %r15, %rdi
callq 0xfc50
movslq 0x8(%r14,%r13), %rsi
movq %r15, %rdi
callq 0xf960
movq %r15, %rdi
movl %ebp, %esi
callq 0xfa70
leal 0x1(%r12), %eax
jmp 0x1cb57
cmpb $0x0, 0x4(%rsp)
je 0x1cbcd
addq $0x8, %r14
xorl %r12d, %r12d
cmpl %ebx, %r12d
jae 0x1cbcd
movslq (%r14), %rsi
movq %r15, %rdi
callq 0xf960
movq -0x8(%r14), %rsi
movq %r15, %rdi
callq 0xfc50
movq %r15, %rdi
movl %ebp, %esi
callq 0xfa70
incl %r12d
addq $0x10, %r14
jmp 0x1cb9e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: rr_type
static int rr_type(lua_State *L) {
	unsigned i;

	lua_settop(L, 2);
	lua_pushnil(L); /* default result */

	if (lua_isuserdata(L, 2)) {
		for (i = 0; i < countof(rrinfo); i++) {
			if (!rrinfo[i].tname)
				continue;
			if (!luaL_testudata(L, 2, rrinfo[i].tname)
			&&  !luaL_testudata(L, 2, RR_ANY_CLASS))
				continue;

			lua_pushstring(L, "dns record");

			break;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x106f0
movq %rbx, %rdi
callq 0xf9d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10740
testl %eax, %eax
je 0x1cc63
xorl %r15d, %r15d
leaq 0x273cf(%rip), %r12     # 0x43fe0
pushq $0x2
popq %rbp
leaq 0x14668(%rip), %r14     # 0x31283
cmpq $0x640, %r15            # imm = 0x640
je 0x1cc63
movq (%r15,%r12), %rdx
testq %rdx, %rdx
je 0x1cc4e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x107e0
testq %rax, %rax
jne 0x1cc54
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x107e0
testq %rax, %rax
jne 0x1cc54
addq $0x10, %r15
jmp 0x1cc1b
leaq 0x1475c(%rip), %rsi     # 0x313b7
movq %rbx, %rdi
callq 0xfc50
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_packet
int luaopen__cqueues_dns_packet(lua_State *L) {
	static const struct cqs_macro section[] = {
		{ "QUESTION", DNS_S_QD }, { "ANSWER", DNS_S_AN },
		{ "AUTHORITY", DNS_S_NS }, { "ADDITIONAL", DNS_S_AR },
	};
	static const struct cqs_macro shortsec[] = {
		{ "QD", DNS_S_QD }, { "AN", DNS_S_AN },
		{ "NS", DNS_S_NS }, { "AR", DNS_S_AR },
	};
	static const struct cqs_macro opcode[] = {
		{ "QUERY", DNS_OP_QUERY }, { "IQUERY", DNS_OP_IQUERY },
		{ "STATUS", DNS_OP_STATUS }, { "NOTIFY", DNS_OP_NOTIFY },
		{ "UPDATE", DNS_OP_UPDATE },
	};
	static const struct cqs_macro rcode[] = {
		{ "NOERROR", DNS_RC_NOERROR }, { "FORMERR", DNS_RC_FORMERR },
		{ "SERVFAIL", DNS_RC_SERVFAIL }, { "NXDOMAIN", DNS_RC_NXDOMAIN },
		{ "NOTIMP", DNS_RC_NOTIMP }, { "REFUSED", DNS_RC_REFUSED },
		{ "YXDOMAIN", DNS_RC_YXDOMAIN }, { "YXRRSET", DNS_RC_YXRRSET },
		{ "NXRRSET", DNS_RC_NXRRSET }, { "NOTAUTH", DNS_RC_NOTAUTH },
		{ "NOTZONE", DNS_RC_NOTZONE },
	};
	static const struct cqs_macro other[] = {
		{ "QBUFSIZ", DNS_P_QBUFSIZ },
	};

	cqs_newmetatable(L, PACKET_CLASS, pkt_methods, pkt_metatable, 0);

	luaL_newlib(L, pkt_globals);

	lua_newtable(L);
	cqs_setmacros(L, -1, section, countof(section), 1);
	cqs_setmacros(L, -1, shortsec, countof(shortsec), 0);
	lua_setfield(L, -2, "section");

	lua_newtable(L);
	cqs_setmacros(L, -1, opcode, countof(opcode), 1);
	lua_setfield(L, -2, "opcode");

	lua_newtable(L);
	cqs_setmacros(L, -1, rcode, countof(rcode), 1);
	lua_setfield(L, -2, "rcode");

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

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x14532(%rip), %rsi     # 0x311af
leaq 0x2673c(%rip), %rdx     # 0x433c0
leaq 0x267d5(%rip), %rcx     # 0x43460
callq 0x1cd93
movsd 0x13368(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x3
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x267c7(%rip), %rsi     # 0x43480
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
leaq 0x2655a(%rip), %rsi     # 0x43230
pushq $0x4
popq %r14
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1cb33
leaq 0x2657f(%rip), %rsi     # 0x43270
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1cb33
leaq 0x144b5(%rip), %rdx     # 0x311ba
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf550
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
leaq 0x26589(%rip), %rsi     # 0x432b0
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x1cb33
leaq 0x14487(%rip), %rdx     # 0x311c2
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf550
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
leaq 0x265a7(%rip), %rsi     # 0x43300
pushq $0xb
popq %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x1cb33
leaq 0x1445c(%rip), %rdx     # 0x311c9
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf550
leaq 0x26631(%rip), %rsi     # 0x433b0
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1cb33
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_config
int luaopen__cqueues_dns_config(lua_State *L) {
	cqs_newmetatable(L, RESCONF_CLASS, resconf_methods, resconf_metatable, 0);

	luaL_newlib(L, resconf_globals);

	lua_pushinteger(L, DNS_RESCONF_TCP_ENABLE);
	lua_setfield(L, -2, "TCP_ENABLE");

	lua_pushinteger(L, DNS_RESCONF_TCP_ONLY);
	lua_setfield(L, -2, "TCP_ONLY");

	lua_pushinteger(L, DNS_RESCONF_TCP_DISABLE);
	lua_setfield(L, -2, "TCP_DISABLE");

	lua_pushinteger(L, RESCONF_RESOLV_CONF);
	lua_setfield(L, -2, "RESOLV_CONF");

	lua_pushinteger(L, RESCONF_NSSWITCH_CONF);
	lua_setfield(L, -2, "NSSWITCH_CONF");

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x143cd(%rip), %rsi     # 0x311cf
leaq 0x266b7(%rip), %rdx     # 0x434c0
leaq 0x26790(%rip), %rcx     # 0x435a0
callq 0x1cd93
movsd 0x131e3(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x5
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x26792(%rip), %rsi     # 0x435d0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf960
leaq 0x14381(%rip), %rdx     # 0x311da
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf550
pushq $0x1
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf960
leaq 0x14369(%rip), %rdx     # 0x311e5
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf550
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf960
leaq 0x14356(%rip), %rdx     # 0x311ee
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf550
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf960
leaq 0x14347(%rip), %rdx     # 0x311fa
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf550
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf960
leaq 0x14337(%rip), %rdx     # 0x31206
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf550
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_hosts
int luaopen__cqueues_dns_hosts(lua_State *L) {
	// not needed until dns_hosts_query bound
	//cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);

	cqs_newmetatable(L, HOSTS_CLASS, hosts_methods, hosts_metatable, 0);

	luaL_newlib(L, hosts_globals);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14328(%rip), %rsi     # 0x31214
leaq 0x2673d(%rip), %rdx     # 0x43630
leaq 0x26776(%rip), %rcx     # 0x43670
callq 0x1cd93
movsd 0x130f9(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x3
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x26778(%rip), %rsi     # 0x436a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_hints
int luaopen__cqueues_dns_hints(lua_State *L) {
	cqs_newmetatable(L, HINTS_CLASS, hints_methods, hints_metatable, 0);

	cqs_requiref(L, "_cqueues.dns.config", &luaopen__cqueues_dns_config, 0);
	// not needed until dns_hints_query bound
	//cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);

	luaL_newlib(L, hints_globals);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x142dc(%rip), %rsi     # 0x3121e
leaq 0x26797(%rip), %rdx     # 0x436e0
leaq 0x267c0(%rip), %rcx     # 0x43710
callq 0x1cd93
leaq 0x142cc(%rip), %rsi     # 0x31228
movq 0x2802d(%rip), %rdx     # 0x44f90
movq %rbx, %rdi
callq 0x1cfa3
movsd 0x1308d(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x5
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x267ac(%rip), %rsi     # 0x43740
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_resolver
int luaopen__cqueues_dns_resolver(lua_State *L) {
	cqs_newmetatable(L, RESOLVER_CLASS, res_methods, res_metatable, 0);

	cqs_requiref(L, "_cqueues.dns.config", &luaopen__cqueues_dns_config, 0);
	cqs_requiref(L, "_cqueues.dns.hosts", &luaopen__cqueues_dns_hosts, 0);
	cqs_requiref(L, "_cqueues.dns.hints", &luaopen__cqueues_dns_hints, 0);
	cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);

	luaL_newlib(L, res_globals);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14206(%rip), %rsi     # 0x3123c
leaq 0x26763(%rip), %rdx     # 0x437a0
leaq 0x267dc(%rip), %rcx     # 0x43820
callq 0x1cd93
leaq 0x141d8(%rip), %rsi     # 0x31228
movq 0x27f39(%rip), %rdx     # 0x44f90
movq %rbx, %rdi
callq 0x1cfa3
leaq 0x141e3(%rip), %rsi     # 0x31249
movq 0x27f5b(%rip), %rdx     # 0x44fc8
movq %rbx, %rdi
callq 0x1cfa3
leaq 0x141e0(%rip), %rsi     # 0x3125c
movq 0x27ee5(%rip), %rdx     # 0x44f68
movq %rbx, %rdi
callq 0x1cfa3
leaq 0x141dd(%rip), %rsi     # 0x3126f
movq 0x27f0f(%rip), %rdx     # 0x44fa8
movq %rbx, %rdi
callq 0x1cfa3
movsd 0x12f57(%rip), %xmm0    # 0x30000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x105e0
pushq $0x3
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
leaq 0x26776(%rip), %rsi     # 0x43840
movq %rbx, %rdi
xorl %edx, %edx
callq 0x102d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: any_rdata
static int any_rdata(lua_State *L) {
	struct rr *rr = rr_toany(L, 1);

	if (rr->attr.section == DNS_S_QD)
		return lua_pushliteral(L, ""), 1;

	lua_pushlstring(L, (char *)rr->data.rdata.data, rr->data.rdata.len);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1d1c6
cmpl $0x1, (%rax)
jne 0x1d1ae
leaq 0x16e57(%rip), %rsi     # 0x33ffb
movq %rbx, %rdi
callq 0xfc50
jmp 0x1d1c1
movq %rax, %rsi
addq $0x30, %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0xf4e0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: any__tostring
static int any__tostring(lua_State *L) {
	struct rr *rr = rr_toany(L, 1);

	if (rr->attr.section == DNS_S_QD)
		return lua_pushliteral(L, ""), 1;

	if (luaL_testudata(L, 1, RR_ANY_CLASS)) {
		lua_pushlstring(L, (char *)rr->data.rdata.data, rr->data.rdata.len);
	} else {
		luaL_Buffer B;
		size_t len;

		luaL_buffinit(L, &B);
		len = dns_any_print(luaL_prepbuffer(&B), LUAL_BUFFERSIZE, &rr->data, rr->attr.type);
		luaL_addsize(&B, len);
		luaL_pushresult(&B);
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r14
callq 0x1d1c6
cmpl $0x1, (%rax)
jne 0x1d236
leaq 0x16dcf(%rip), %rsi     # 0x33ffb
movq %r14, %rdi
callq 0xfc50
jmp 0x1d2a3
movq %rax, %rbx
leaq 0x14043(%rip), %rdx     # 0x31283
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x107e0
testq %rax, %rax
je 0x1d265
movq %rbx, %rsi
addq $0x30, %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0xf4e0
jmp 0x1d2a3
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x106e0
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdi
callq 0xf3c0
movq %rbx, %rdx
addq $0x20, %rdx
movl 0x8(%rbx), %ecx
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rdi
callq 0xf8b0
addq %rax, 0x10(%r15)
movq %r15, %rdi
callq 0x107d0
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq