LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_drop_memberships
int nl_socket_drop_memberships(struct nl_sock *sk, int group, ...)
{
	int err;
	va_list ap;

	if (sk->s_fd == -1)
		return -NLE_BAD_SOCK;

	va_start(ap, group);

	while (group != 0) {
		if (group < 0)
			return -NLE_INVAL;

		err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
						 &group, sizeof(group));
		if (err < 0)
			return -nl_syserr2nlerr(errno);

		group = va_arg(ap, int);
	}

	va_end(ap);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x6f78
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x6fb1
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x70a5
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x0, -0x14(%rbp)
je 0x709a
cmpl $0x0, -0x14(%rbp)
jge 0x6ff1
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x70a5
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x7031
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x70a5
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x706c
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x7089
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x6fd5
leaq -0x30(%rbp), %rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_set_nonblocking
int nl_socket_set_nonblocking(struct nl_sock *sk)
{
	if (sk->s_fd == -1)
		return -NLE_BAD_SOCK;

	if (fcntl(sk->s_fd, F_SETFL, O_NONBLOCK) < 0)
		return -nl_syserr2nlerr(errno);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x70df
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x711a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
movb $0x0, %al
callq 0x3160
cmpl $0x0, %eax
jge 0x7113
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x711a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_set_buffer_size
int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
{
	int err;

	if (rxbuf <= 0)
		rxbuf = 32768;

	if (txbuf <= 0)
		txbuf = 32768;

	if (sk->s_fd == -1)
		return -NLE_BAD_SOCK;
	
	err = setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF,
			 &txbuf, sizeof(txbuf));
	if (err < 0)
		return -nl_syserr2nlerr(errno);

	err = setsockopt(sk->s_fd, SOL_SOCKET, SO_RCVBUF,
			 &rxbuf, sizeof(rxbuf));
	if (err < 0)
		return -nl_syserr2nlerr(errno);

	sk->s_flags |= NL_SOCK_BUFSIZE_SET;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x714f
movl $0x8000, -0x14(%rbp)    # imm = 0x8000
cmpl $0x0, -0x18(%rbp)
jg 0x715c
movl $0x8000, -0x18(%rbp)    # imm = 0x8000
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x7172
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x7206
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x1, %esi
movl $0x7, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x71b2
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7206
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x1, %esi
movl $0x8, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x71f2
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7206
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_set_passcred
int nl_socket_set_passcred(struct nl_sock *sk, int state)
{
	int err;

	if (sk->s_fd == -1)
		return -NLE_BAD_SOCK;

	err = setsockopt(sk->s_fd, SOL_SOCKET, SO_PASSCRED,
			 &state, sizeof(state));
	if (err < 0)
		return -nl_syserr2nlerr(errno);

	if (state)
		sk->s_flags |= NL_SOCK_PASSCRED;
	else
		sk->s_flags &= ~NL_SOCK_PASSCRED;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x7232
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x729b
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x1, %esi
movl $0x10, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x7272
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x729b
cmpl $0x0, -0x14(%rbp)
je 0x7287
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x28(%rax)
jmp 0x7294
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0x28(%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/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_recv_pktinfo
int nl_socket_recv_pktinfo(struct nl_sock *sk, int state)
{
	int err;

	if (sk->s_fd == -1)
		return -NLE_BAD_SOCK;

	err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_PKTINFO,
			 &state, sizeof(state));
	if (err < 0)
		return -nl_syserr2nlerr(errno);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x72d2
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x7319
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x3, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x7312
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7319
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/error.c
// Function: nl_geterror
const char *nl_geterror(int error)
{
	error = abs(error);

	if (error > NLE_MAX)
		error = NLE_FAILURE;

	return errmsg[error];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x4(%rbp)
cmpl $0x21, -0x4(%rbp)
jle 0x7351
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x7044(%rip), %rax      # 0xe3a0
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/error.c
// Function: nl_syserr2nlerr
int nl_syserr2nlerr(int error)
{
	error = abs(error);

	switch (error) {
	case EBADF:		return NLE_BAD_SOCK;
	case EADDRINUSE:	return NLE_EXIST;
	case EEXIST:		return NLE_EXIST;
	case EADDRNOTAVAIL:	return NLE_NOADDR;
	case ESRCH:		/* fall through */
	case ENOENT:		return NLE_OBJ_NOTFOUND;
	case EINTR:		return NLE_INTR;
	case EAGAIN:		return NLE_AGAIN;
	case ENOTSOCK:		return NLE_BAD_SOCK;
	case ENOPROTOOPT:	return NLE_INVAL;
	case EFAULT:		return NLE_INVAL;
	case EACCES:		return NLE_NOACCESS;
	case EINVAL:		return NLE_INVAL;
	case ENOBUFS:		return NLE_NOMEM;
	case ENOMEM:		return NLE_NOMEM;
	case EAFNOSUPPORT:	return NLE_AF_NOSUPPORT;
	case EPROTONOSUPPORT:	return NLE_PROTO_MISMATCH;
	case EOPNOTSUPP:	return NLE_OPNOTSUPP;
	case EPERM:		return NLE_PERM;
	case EBUSY:		return NLE_BUSY;
	case ERANGE:		return NLE_RANGE;
	case ENODEV:		return NLE_NODEV;
	default:		return NLE_FAILURE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x68, %eax
ja 0x750e
movq -0x10(%rbp), %rax
leaq 0x2e39(%rip), %rcx      # 0xa26c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x7515
movl $0x6, -0x4(%rbp)
jmp 0x7515
movl $0x6, -0x4(%rbp)
jmp 0x7515
movl $0x13, -0x4(%rbp)
jmp 0x7515
movl $0xc, -0x4(%rbp)
jmp 0x7515
movl $0x2, -0x4(%rbp)
jmp 0x7515
movl $0x4, -0x4(%rbp)
jmp 0x7515
movl $0x3, -0x4(%rbp)
jmp 0x7515
movl $0x7, -0x4(%rbp)
jmp 0x7515
movl $0x7, -0x4(%rbp)
jmp 0x7515
movl $0x1b, -0x4(%rbp)
jmp 0x7515
movl $0x7, -0x4(%rbp)
jmp 0x7515
movl $0x5, -0x4(%rbp)
jmp 0x7515
movl $0x5, -0x4(%rbp)
jmp 0x7515
movl $0xb, -0x4(%rbp)
jmp 0x7515
movl $0x1a, -0x4(%rbp)
jmp 0x7515
movl $0xa, -0x4(%rbp)
jmp 0x7515
movl $0x1c, -0x4(%rbp)
jmp 0x7515
movl $0x19, -0x4(%rbp)
jmp 0x7515
movl $0x8, -0x4(%rbp)
jmp 0x7515
movl $0x1f, -0x4(%rbp)
jmp 0x7515
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl.c
// Function: genl_send_simple
int genl_send_simple(struct nl_sock *sk, int family, int cmd,
		     int version, int flags)
{
	struct genlmsghdr hdr = {
		.cmd = cmd,
		.version = version,
	};

	return nl_send_simple(sk, family, flags, &hdr, sizeof(hdr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x10(%rbp), %eax
movb %al, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x1b(%rbp)
movw $0x0, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x1c(%rbp), %rcx
movl $0x4, %r8d
callq 0x3080
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl.c
// Function: genlmsg_valid_hdr
int genlmsg_valid_hdr(struct nlmsghdr *nlh, int hdrlen)
{
	struct genlmsghdr *ghdr;

	if (!nlmsg_valid_hdr(nlh, GENL_HDRLEN))
		return 0;

	ghdr = nlmsg_data(nlh);
	if ((unsigned) genlmsg_len(ghdr) < NLMSG_ALIGN(hdrlen))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x7600
cmpl $0x0, %eax
jne 0x75bb
movl $0x0, -0x4(%rbp)
jmp 0x75f1
movq -0x10(%rbp), %rdi
callq 0x7650
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3450
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
subl $0x1, %ecx
andl $-0x4, %ecx
cmpl %ecx, %eax
jae 0x75ea
movl $0x0, -0x4(%rbp)
jmp 0x75f1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl.c
// Function: genlmsg_validate
int genlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
		   struct nla_policy *policy)
{
	struct genlmsghdr *ghdr;

	if (!genlmsg_valid_hdr(nlh, hdrlen))
		return -NLE_MSG_TOOSHORT;

	ghdr = nlmsg_data(nlh);
	return nla_validate(genlmsg_attrdata(ghdr, hdrlen),
			    genlmsg_attrlen(ghdr, hdrlen), maxtype, policy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3280
cmpl $0x0, %eax
jne 0x76d0
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x770e
movq -0x10(%rbp), %rdi
callq 0x7650
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3560
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3480
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x35f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl.c
// Function: genlmsg_parse
int genlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
		  int maxtype, struct nla_policy *policy)
{
	struct genlmsghdr *ghdr;

	if (!genlmsg_valid_hdr(nlh, hdrlen))
		return -NLE_MSG_TOOSHORT;

	ghdr = nlmsg_data(nlh);
	return nla_parse(tb, maxtype, genlmsg_attrdata(ghdr, hdrlen),
			 genlmsg_attrlen(ghdr, hdrlen), policy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3280
cmpl $0x0, %eax
jne 0x77b4
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x7804
movq -0x10(%rbp), %rdi
callq 0x7650
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3560
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3480
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %r8
callq 0x3370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl.c
// Function: genlmsg_put
void *genlmsg_put(struct nl_msg *msg, uint32_t pid, uint32_t seq, int family,
		  int hdrlen, int flags, uint8_t cmd, uint8_t version)
{
	struct nlmsghdr *nlh;
	struct genlmsghdr hdr = {
		.cmd = cmd,
		.version = version,
	};

	nlh = nlmsg_put(msg, pid, seq, family, GENL_HDRLEN + hdrlen, flags);
	if (nlh == NULL)
		return NULL;

	memcpy(nlmsg_data(nlh), &hdr, sizeof(hdr));
	NL_DBG(2, "msg %p: Added generic netlink header cmd=%d version=%d\n",
	       msg, cmd, version);

	return nlmsg_data(nlh) + GENL_HDRLEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb 0x18(%rbp), %al
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb 0x10(%rbp), %al
movb %al, -0x34(%rbp)
movb 0x18(%rbp), %al
movb %al, -0x33(%rbp)
movw $0x0, -0x32(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movslq -0x20(%rbp), %rax
addq $0x4, %rax
movl %eax, %r8d
movl -0x24(%rbp), %r9d
callq 0x33a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x789b
movq $0x0, -0x8(%rbp)
jmp 0x78bc
movq -0x30(%rbp), %rdi
callq 0x7650
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x78ab
movq -0x30(%rbp), %rdi
callq 0x7650
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_family.c
// Function: genl_family_add_op
int genl_family_add_op(struct genl_family *family, int id, int flags)
{
	struct genl_family_op *op;

	op = calloc(1, sizeof(*op));
	if (op == NULL)
		return -NLE_NOMEM;

	op->o_id = id;
	op->o_flags = flags;

	nl_list_add_tail(&op->o_list, &family->gf_ops);
	family->ce_mask |= FAMILY_ATTR_OPS;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x32c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7995
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x79d1
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
callq 0x79e0
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_family.c
// Function: genl_family_add_grp
int genl_family_add_grp(struct genl_family *family, uint32_t id,
			const char *name)
{
	struct genl_family_grp *grp;

	grp = calloc(1, sizeof(*grp));
	if (grp == NULL)
		return -NLE_NOMEM;

	grp->id = id;
	strncpy(grp->name, name, GENL_NAMSIZ - 1);
	grp->name[GENL_NAMSIZ - 1] = '\0';

	nl_list_add_tail(&grp->list, &family->gf_mc_grps);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x32c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7a46
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x7a8a
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movl $0xf, %edx
callq 0x30c0
movq -0x28(%rbp), %rax
movb $0x0, 0x27(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
callq 0x79e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_family.c
// Function: family_free_data
static void family_free_data(struct nl_object *c)
{
	struct genl_family *family = (struct genl_family *) c;
	struct genl_family_op *ops, *tmp;
	struct genl_family_grp *grp, *t_grp;

	if (family == NULL)
		return;

	nl_list_for_each_entry_safe(ops, tmp, &family->gf_ops, o_list) {
		nl_list_del(&ops->o_list);
		free(ops);
	}

	nl_list_for_each_entry_safe(grp, t_grp, &family->gf_mc_grps, list) {
		nl_list_del(&grp->list);
		free(grp);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b23
jmp 0x7c59
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
je 0x7bb8
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x7fd0
movq -0x18(%rbp), %rdi
callq 0x3070
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b63
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
addq $0x68, %rcx
cmpq %rcx, %rax
je 0x7c59
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x7fd0
movq -0x28(%rbp), %rdi
callq 0x3070
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7bf8
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_family.c
// Function: family_clone
static int family_clone(struct nl_object *_dst, struct nl_object *_src)
{
	struct genl_family *dst = nl_object_priv(_dst);
	struct genl_family *src = nl_object_priv(_src);
	struct genl_family_op *ops;
	struct genl_family_grp *grp;
	int err;

	nl_list_for_each_entry(ops, &src->gf_ops, o_list) {
		err = genl_family_add_op(dst, ops->o_id, ops->o_flags);
		if (err < 0)
			return err;
	}

	nl_list_for_each_entry(grp, &src->gf_mc_grps, list) {
		err = genl_family_add_grp(dst, grp->id, grp->name);
		if (err < 0)
			return err;
	}

	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8000
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8000
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
je 0x7d20
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x3230
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x7cfc
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7da9
jmp 0x7cfe
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7cbd
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
addq $0x68, %rcx
cmpq %rcx, %rax
je 0x7da2
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x38(%rbp), %rdx
addq $0x18, %rdx
callq 0x33c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x7d7e
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7da9
jmp 0x7d80
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x7d40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_ctrl.c
// Function: genl_ctrl_search
struct genl_family *genl_ctrl_search(struct nl_cache *cache, int id)
{
	struct genl_family *fam;

	if (cache->c_ops != &genl_ctrl_ops)
		BUG();

	nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
		if (fam->gf_id == id) {
			nl_object_get((struct nl_object *) fam);
			return fam;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
leaq 0x64ee(%rip), %rcx      # 0xe548
cmpq %rcx, 0x20(%rax)
je 0x80a5
jmp 0x8062
movq 0x5f8f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x1fce(%rip), %rsi      # 0xa041
leaq 0x26e7(%rip), %rdx      # 0xa761
movl $0xcb, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x1fcb(%rip), %rdi      # 0xa058
leaq 0x26cd(%rip), %rsi      # 0xa761
movl $0xcb, %edx
leaq 0x26cd(%rip), %rcx      # 0xa76d
callq 0x3210
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0x8119
movq -0x20(%rbp), %rax
movzwl 0x34(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x80f5
movq -0x20(%rbp), %rdi
callq 0x8130
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8121
jmp 0x80f7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x80c4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_ctrl.c
// Function: genl_ctrl_search_by_name
struct genl_family *genl_ctrl_search_by_name(struct nl_cache *cache,
					    const char *name)
{
	struct genl_family *fam;

	if (cache->c_ops != &genl_ctrl_ops)
		BUG();

	nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
		if (!strcmp(name, fam->gf_name)) {
			nl_object_get((struct nl_object *) fam);
			return fam;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
leaq 0x63dd(%rip), %rcx      # 0xe548
cmpq %rcx, 0x20(%rax)
je 0x81b6
jmp 0x8173
movq 0x5e7e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x1ebd(%rip), %rsi      # 0xa041
leaq 0x25d6(%rip), %rdx      # 0xa761
movl $0xee, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x1eba(%rip), %rdi      # 0xa058
leaq 0x25bc(%rip), %rsi      # 0xa761
movl $0xee, %edx
leaq 0x25f9(%rip), %rcx      # 0xa7aa
callq 0x3210
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0x8233
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x36, %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x820f
movq -0x20(%rbp), %rdi
callq 0x8130
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x823b
jmp 0x8211
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x81d5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_ctrl.c
// Function: genl_ctrl_resolve
int genl_ctrl_resolve(struct nl_sock *sk, const char *name)
{
	struct nl_cache *cache;
	struct genl_family *family;
	int err;

	if ((err = genl_ctrl_alloc_cache(sk, &cache)) < 0)
		return err;

	family = genl_ctrl_search_by_name(cache, name);
	if (family == NULL) {
		err = -NLE_OBJ_NOTFOUND;
		goto errout;
	}

	err = genl_family_get_id(family);
	genl_family_put(family);
errout:
	nl_cache_free(cache);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x827d
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x82c2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3520
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x829e
movl $0xfffffff4, -0x2c(%rbp) # imm = 0xFFFFFFF4
jmp 0x82b3
movq -0x28(%rbp), %rdi
callq 0x82d0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3120
movq -0x20(%rbp), %rdi
callq 0x3050
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_ctrl.c
// Function: genl_ctrl_resolve_grp
int genl_ctrl_resolve_grp(struct nl_sock *sk, const char *family_name,
	const char *grp_name)
{
	struct nl_cache *cache;
	struct genl_family *family;
	int err;

	if ((err = genl_ctrl_alloc_cache(sk, &cache)) < 0)
		return err;

	family = genl_ctrl_search_by_name(cache, family_name);
	if (family == NULL) {
		err = -NLE_OBJ_NOTFOUND;
		goto errout;
	}

	err = genl_ctrl_grp_by_name(family, grp_name);
	genl_family_put(family);
errout:
	nl_cache_free(cache);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31d0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x8331
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x837a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3520
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8352
movl $0xfffffff4, -0x34(%rbp) # imm = 0xFFFFFFF4
jmp 0x836b
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8390
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3120
movq -0x28(%rbp), %rdi
callq 0x3050
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_ctrl.c
// Function: genl_ctrl_grp_by_name
static int genl_ctrl_grp_by_name(const struct genl_family *family,
				const char *grp_name)
{
	struct genl_family_grp *grp;

	nl_list_for_each_entry(grp, &family->gf_mc_grps, list) {
		if (!strcmp(grp->name, grp_name)) {
			return grp->id;
		}
	}

	return -NLE_OBJ_NOTFOUND;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
addq $0x68, %rcx
cmpq %rcx, %rax
je 0x841b
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x83f7
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x8422
jmp 0x83f9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x83c0
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/genl_mngt.c
// Function: genl_register
int genl_register(struct nl_cache_ops *ops)
{
	int err;

	if (ops->co_protocol != NETLINK_GENERIC) {
		err = -NLE_PROTO_MISMATCH;
		goto errout;
	}

	if ((size_t) ops->co_hdrsize < GENL_HDRSIZE(0)) {
		err = -NLE_INVAL;
		goto errout;
	}

	if (ops->co_genl == NULL) {
		err = -NLE_INVAL;
		goto errout;
	}

	ops->co_genl->o_cache_ops = ops;
	ops->co_genl->o_name = ops->co_msgtypes[0].mt_name;
	ops->co_genl->o_family = ops->co_msgtypes[0].mt_id;
	ops->co_msg_parser = genl_msg_parser;

	/* FIXME: check for dup */

	nl_list_add_tail(&ops->co_genl->o_list, &genl_ops_list);

	err = nl_cache_mngt_register(ops);
errout:
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10, 0xc(%rax)
je 0x8a82
movl $0xffffffe6, -0xc(%rbp) # imm = 0xFFFFFFE6
jmp 0x8b15
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
cmpq $0x4, %rax
jae 0x8a99
movl $0xfffffff9, -0xc(%rbp) # imm = 0xFFFFFFF9
jmp 0x8b15
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x8aad
movl $0xfffffff9, -0xc(%rbp) # imm = 0xFFFFFFF9
jmp 0x8b15
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x33(%rip), %rcx        # 0x8b20
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x28, %rdi
leaq 0x5c04(%rip), %rsi      # 0xe708
callq 0x8ce0
movq -0x8(%rbp), %rdi
callq 0x30e0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_genl_init
int unl_genl_init(struct unl *unl, const char *family)
{
	if (unl_init(unl))
		goto error_out;

	unl->hdrlen = NLMSG_ALIGN(sizeof(struct genlmsghdr));
	unl->family_name = strdup(family);
	if (!unl->family_name)
		goto error;

	if (genl_connect(unl->sock))
		goto error;

	if (genl_ctrl_alloc_cache(unl->sock, &unl->cache))
		goto error;

	unl->family = genl_ctrl_search_by_name(unl->cache, family);
	if (!unl->family)
		goto error;

	return 0;

error:
	unl_free(unl);
error_out:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ea0
cmpl $0x0, %eax
je 0x8df3
jmp 0x8e88
movq -0x10(%rbp), %rax
movl $0x4, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x3670
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8e1f
jmp 0x8e7f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3320
cmpl $0x0, %eax
je 0x8e32
jmp 0x8e7f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x31d0
cmpl $0x0, %eax
je 0x8e4d
jmp 0x8e7f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8e76
jmp 0x8e7f
movl $0x0, -0x4(%rbp)
jmp 0x8e8f
movq -0x10(%rbp), %rdi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_init
static int unl_init(struct unl *unl)
{
	memset(unl, 0, sizeof(*unl));

	unl->sock = nl_socket_alloc();
	if (!unl->sock)
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3240
callq 0x3310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8ede
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8ee5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_free
void unl_free(struct unl *unl)
{
	if (unl->family_name)
		free(unl->family_name);

	if (unl->sock)
		nl_socket_free(unl->sock);

	if (unl->cache)
		nl_cache_free(unl->cache);

	memset(unl, 0, sizeof(*unl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8f14
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3070
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8f2a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x35a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8f42
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_rtnl_init
int unl_rtnl_init(struct unl *unl)
{
	if (unl_init(unl))
		goto error_out;

	unl->hdrlen = 0;
	if (nl_connect(unl->sock, NETLINK_ROUTE))
		goto error;

	return 0;

error:
	unl_free(unl);
error_out:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ea0
cmpl $0x0, %eax
je 0x8f7c
jmp 0x8fae
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3040
cmpl $0x0, %eax
je 0x8f9c
jmp 0x8fa5
movl $0x0, -0x4(%rbp)
jmp 0x8fb5
movq -0x10(%rbp), %rdi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_genl_msg
struct nl_msg *unl_genl_msg(struct unl *unl, int cmd, bool dump)
{
	struct nl_msg *msg;
	int flags = 0;

	msg = nlmsg_alloc();
	if (!msg)
		goto out;

	if (dump)
		flags |= NLM_F_DUMP;

	genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ,
		    genl_family_get_id(unl->family), 0, flags, cmd, 0);

out:
	return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x35e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8fef
jmp 0x903e
testb $0x1, -0xd(%rbp)
je 0x9000
movl -0x1c(%rbp), %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9050
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movl -0x1c(%rbp), %r9d
movl -0xc(%rbp), %eax
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movzbl %al, %eax
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3580
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_rtnl_msg
struct nl_msg *unl_rtnl_msg(struct unl *unl, int cmd, bool dump)
{
	struct nl_msg *msg;
	int flags = 0;

	msg = nlmsg_alloc();
	if (!msg)
		goto out;

	if (dump)
		flags |= NLM_F_DUMP;

	nlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, cmd, 0, flags);

out:
	return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x35e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x90af
jmp 0x90d9
testb $0x1, -0xd(%rbp)
je 0x90c0
movl -0x1c(%rbp), %eax
orl $0x300, %eax            # imm = 0x300
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %r9d
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
callq 0x33a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_request
int unl_request(struct unl *unl, struct nl_msg *msg, unl_cb handler, void *arg)
{
	struct nl_cb *cb;
	int err;

	cb = nl_cb_alloc(NL_CB_CUSTOM);
	err = nl_send_auto_complete(unl->sock, msg);
	if (err < 0)
		goto out;

	err = 1;
	nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
	nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
	if (handler)
		nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, handler, arg);

	while (err > 0)
		nl_recvmsgs(unl->sock, cb);

out:
	nlmsg_free(msg);
	nl_cb_put(cb);
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x3, %edi
callq 0x3100
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x35b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x9134
jmp 0x91cb
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl $0x3, %esi
leaq 0xa5(%rip), %rdx        # 0x91f0
leaq -0x2c(%rbp), %rcx
callq 0x3600
movq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
leaq 0xb7(%rip), %rcx        # 0x9220
leaq -0x2c(%rbp), %r8
callq 0x3690
movq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0x3, %edx
leaq 0xc9(%rip), %rcx        # 0x9250
leaq -0x2c(%rbp), %r8
callq 0x3690
cmpq $0x0, -0x18(%rbp)
je 0x91af
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %esi, %esi
movl $0x3, %edx
callq 0x3690
jmp 0x91b1
cmpl $0x0, -0x2c(%rbp)
jle 0x91c9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3190
jmp 0x91b1
jmp 0x91cb
movq -0x10(%rbp), %rdi
callq 0x3640
movq -0x28(%rbp), %rdi
callq 0x3300
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: request_single_cb
static int request_single_cb(struct nl_msg *msg, void *arg)
{
	struct nl_msg **dest = arg;

	if (!*dest) {
		nlmsg_get(msg);
		*dest = msg;
	}
	return NL_SKIP;
}

// 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, (%rax)
jne 0x92f6
movq -0x8(%rbp), %rdi
callq 0x98a0
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_loop
void unl_loop(struct unl *unl, unl_cb handler, void *arg)
{
	struct nl_cb *cb;

	cb = nl_cb_alloc(NL_CB_CUSTOM);
	unl->loop_done = false;
	nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, handler, arg);

	while (!unl->loop_done)
		nl_recvmsgs(unl->sock, cb);

	nl_cb_put(cb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, %edi
callq 0x3100
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0x3, %edx
leaq 0x61(%rip), %rcx        # 0x93b0
xorl %eax, %eax
movl %eax, %r8d
callq 0x3690
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
xorl %esi, %esi
movl $0x3, %edx
callq 0x3690
movq -0x8(%rbp), %rax
movb 0x24(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9380
jmp 0x9392
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3190
jmp 0x9371
movq -0x20(%rbp), %rdi
callq 0x3300
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_genl_subscribe
int unl_genl_subscribe(struct unl *unl, const char *name)
{
	int mcid;

	mcid = unl_genl_multicast_id(unl, name);
	if (mcid < 0)
		return mcid;

	return nl_socket_add_membership(unl->sock, mcid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3490
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x965e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9670
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x9680
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_nl80211_phy_lookup
int unl_nl80211_phy_lookup(const char *name)
{
	char buf[32];
	int fd, pos;

	snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);

	fd = open(buf, O_RDONLY);
	if (fd < 0)
		return -1;
	pos = read(fd, buf, sizeof(buf) - 1);
	if (pos < 0) {
		close(fd);
		return -1;
	}
	buf[pos] = '\0';
	close(fd);
	return atoi(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
leaq 0x1155(%rip), %rdx      # 0xa8a5
movb $0x0, %al
callq 0x3200
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x34f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x9776
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x97be
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl $0x1f, %edx
callq 0x32b0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x97a1
movl -0x34(%rbp), %edi
callq 0x3270
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x97be
movslq -0x38(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
movl -0x34(%rbp), %edi
callq 0x3270
leaq -0x30(%rbp), %rdi
callq 0x3590
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/unl.c
// Function: unl_nl80211_wdev_to_phy
int unl_nl80211_wdev_to_phy(struct unl *unl, int wdev)
{
	struct nl_msg *msg;
	struct nlattr *attr;
	int ret = -1;

	msg = unl_genl_msg(unl, NL80211_CMD_GET_INTERFACE, false);
	if (!msg)
		return -1;

	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, wdev);
	if (unl_request_single(unl, msg, &msg) < 0)
		return -1;

	attr = unl_find_attr(unl, msg, NL80211_ATTR_WIPHY);
	if (!attr)
		goto out;

	ret = nla_get_u32(attr);
out:
nla_put_failure:
	nlmsg_free(msg);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x31f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x980d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9892
jmp 0x980f
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3, %esi
movl $0x4, %edx
leaq -0x30(%rbp), %rcx
callq 0x33f0
cmpl $0x0, %eax
jge 0x9833
jmp 0x9883
jmp 0x9835
jmp 0x9837
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3340
cmpl $0x0, %eax
jge 0x9856
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9892
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x9590
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9875
jmp 0x9881
movq -0x28(%rbp), %rdi
callq 0x9610
movl %eax, -0x2c(%rbp)
jmp 0x9883
movq -0x20(%rbp), %rdi
callq 0x3640
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomka[P]cliaspora/cliaspora.c
// Function: create_session
static session_t *
create_session()
{
	session_t *sp;

	errno = 0;
	if (cfg.host == NULL || cfg.host[0] == '\0') {
		warnx("Host not defined. Corrupted config file?");
		return (NULL);
	}
	if (cfg.cookie == NULL || cfg.cookie[0] == '\0') {
		warnx("Cookie not defined. Corrupted config file?");
		return (NULL);
	}
	if ((sp = malloc(sizeof(session_t))) == NULL)
		return (NULL);

	sp->host	 = cfg.host;
	sp->port	 = cfg.port;
	sp->cookie	 = cfg.cookie; 
	sp->attr.name	 = sp->attr.did = NULL;
	sp->attr.aspects = NULL;

	if (get_attributs(sp) == -1) {
		free_session(sp); return (NULL);
	}
	return (sp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2060
movl $0x0, (%rax)
leaq 0xea26(%rip), %rax      # 0x12410
cmpq $0x0, 0x10(%rax)
je 0x3a04
leaq 0xea18(%rip), %rax      # 0x12410
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3a1f
leaq 0xb33b(%rip), %rdi      # 0xed46
movb $0x0, %al
callq 0x22f0
movq $0x0, -0x8(%rbp)
jmp 0x3b02
leaq 0xe9ea(%rip), %rax      # 0x12410
cmpq $0x0, 0x18(%rax)
je 0x3a40
leaq 0xe9dc(%rip), %rax      # 0x12410
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3a5b
leaq 0xb328(%rip), %rdi      # 0xed6f
movb $0x0, %al
callq 0x22f0
movq $0x0, -0x8(%rbp)
jmp 0x3b02
movl $0x60, %edi
callq 0x2430
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3a7c
movq $0x0, -0x8(%rbp)
jmp 0x3b02
leaq 0xe98d(%rip), %rax      # 0x12410
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0xe97b(%rip), %rax      # 0x12410
movl (%rax), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
leaq 0xe967(%rip), %rax      # 0x12410
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rdi
callq 0x7690
cmpl $-0x1, %eax
jne 0x3afa
movq -0x10(%rbp), %rdi
callq 0x7020
movq $0x0, -0x8(%rbp)
jmp 0x3b02
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)