LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_send_simple
int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf,
		   size_t size)
{
	int err;
	struct nl_msg *msg;

	msg = nlmsg_alloc_simple(type, flags);
	if (!msg)
		return -NLE_NOMEM;

	if (buf && size) {
		err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
		if (err < 0)
			goto errout;
	}
	

	err = nl_send_auto_complete(sk, msg);
errout:
	nlmsg_free(msg);

	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %r14
movl %esi, %edi
movl %edx, %esi
callq 0x30f0
testq %rax, %rax
je 0x3dab
movq %rax, %rbx
testq %r12, %r12
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x3d94
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x4, %ecx
callq 0x3610
testl %eax, %eax
js 0x3d9f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3500
movl %eax, %ebp
movq %rbx, %rdi
callq 0x35a0
jmp 0x3db0
movl $0xfffffffb, %ebp       # imm = 0xFFFFFFFB
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_wait_for_ack
int nl_wait_for_ack(struct nl_sock *sk)
{
	int err;
	struct nl_cb *cb;

	cb = nl_cb_clone(sk->s_cb);
	if (cb == NULL)
		return -NLE_NOMEM;

	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
	err = nl_recvmsgs(sk, cb);
	nl_cb_put(cb);

	return err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
callq 0x33e0
testq %rax, %rax
je 0x44e5
movq %rax, %rbx
leaq 0x38(%rip), %rcx        # 0x44ef
movq %rax, %rdi
movl $0x4, %esi
movl $0x3, %edx
xorl %r8d, %r8d
callq 0x35f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3170
movl %eax, %ebp
movq %rbx, %rdi
callq 0x32b0
movl %ebp, %eax
jmp 0x44ea
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_alloc
struct nl_cb *nl_cb_alloc(enum nl_cb_kind kind)
{
	int i;
	struct nl_cb *cb;

	if (kind < 0 || kind > NL_CB_KIND_MAX)
		return NULL;

	cb = calloc(1, sizeof(*cb));
	if (!cb)
		return NULL;

	cb->cb_refcnt = 1;

	for (i = 0; i <= NL_CB_TYPE_MAX; i++)
		nl_cb_set(cb, i, kind, NULL, NULL);

	nl_cb_err(cb, kind, NULL, NULL);

	return cb;
}

// Assembly:
cmpl $0x3, %edi
jbe 0x4500
xorl %eax, %eax
retq
pushq %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0xd0, %esi
callq 0x3270
testq %rax, %rax
je 0x454d
movl $0x1, 0xc8(%rax)
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x3, %ebx
jne 0x4533
movq %rcx, (%rax,%rdx,8)
movq %rcx, 0x50(%rax,%rdx,8)
incq %rdx
cmpq $0xa, %rdx
jne 0x4525
cmpl $0x3, %ebx
jne 0x454f
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rax)
jmp 0x454f
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_clone
struct nl_cb *nl_cb_clone(struct nl_cb *orig)
{
	struct nl_cb *cb;
	
	cb = nl_cb_alloc(NL_CB_DEFAULT);
	if (!cb)
		return NULL;

	memcpy(cb, orig, sizeof(*orig));
	cb->cb_refcnt = 1;

	return cb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0xd0, %esi
callq 0x3270
testq %rax, %rax
je 0x45c5
movq %rax, %rbx
movl $0x1, 0xc8(%rax)
jmp 0x45c7
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x45e8
movl $0xd0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32e0
movl $0x1, 0xc8(%rbx)
jmp 0x45ea
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_put
void nl_cb_put(struct nl_cb *cb)
{
	if (!cb)
		return;

	cb->cb_refcnt--;

	if (cb->cb_refcnt < 0)
		BUG();

	if (cb->cb_refcnt <= 0)
		free(cb);
}

// Assembly:
testq %rdi, %rdi
je 0x4616
movl 0xc8(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc8(%rdi)
testl %eax, %eax
jle 0x4617
cmpl $0x1, %eax
je 0x3060
retq
pushq %rax
callq 0x3650
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_ok
int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
{
	size_t r = remaining;

	return (r >= sizeof(struct nlmsghdr) &&
		nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
		nlh->nlmsg_len <= r);
}

// Assembly:
xorl %eax, %eax
cmpl $0x10, %esi
jb 0x463a
movl (%rdi), %ecx
cmpq $0x10, %rcx
jb 0x463a
movslq %esi, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_validate
int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
		   struct nla_policy *policy)
{
	if (!nlmsg_valid_hdr(nlh, hdrlen))
		return -NLE_MSG_TOOSHORT;

	return nla_validate(nlmsg_attrdata(nlh, hdrlen),
			    nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
}

// Assembly:
movl %esi, %eax
movl (%rdi), %esi
leal 0x10(%rax), %r8d
cmpl %r8d, %esi
jae 0x4691
movl $0xffffffeb, %eax       # imm = 0xFFFFFFEB
retq
addl $0x3, %eax
andl $-0x4, %eax
addq %rax, %rdi
addq $0x10, %rdi
subl %eax, %esi
addl $-0x10, %esi
jmp 0x3540
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: _nlmsg_alloc
static struct nl_msg *__nlmsg_alloc(size_t len)
{
	struct nl_msg *nm;

	nm = calloc(1, sizeof(*nm));
	if (!nm)
		goto errout;

	nm->nm_refcnt = 1;

	nm->nm_nlh = malloc(len);
	if (!nm->nm_nlh)
		goto errout;

	memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));

	nm->nm_protocol = -1;
	nm->nm_size = len;
	nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);

	NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);

	return nm;
errout:
	free(nm);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x48, %esi
callq 0x3270
movq %rax, %rbx
testq %rax, %rax
je 0x46ff
movl $0x1, 0x40(%rbx)
movq %r14, %rdi
callq 0x3380
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x46ff
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq %r14, 0x38(%rbx)
movl $0x10, (%rax)
jmp 0x4709
movq %rbx, %rdi
callq 0x3060
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_inherit
struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
{
	struct nl_msg *nm;

	nm = nlmsg_alloc();
	if (nm && hdr) {
		struct nlmsghdr *new = nm->nm_nlh;

		new->nlmsg_type = hdr->nlmsg_type;
		new->nlmsg_flags = hdr->nlmsg_flags;
		new->nlmsg_seq = hdr->nlmsg_seq;
		new->nlmsg_pid = hdr->nlmsg_pid;
	}

	return nm;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x6c07(%rip), %rdi      # 0xb328
callq 0x46b1
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x4756
movq 0x30(%rax), %rcx
movzwl 0x4(%rbx), %edx
movw %dx, 0x4(%rcx)
movzwl 0x6(%rbx), %edx
movw %dx, 0x6(%rcx)
movl 0x8(%rbx), %edx
movl %edx, 0x8(%rcx)
movl 0xc(%rbx), %edx
movl %edx, 0xc(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_alloc_simple
struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
{
	struct nl_msg *msg;
	struct nlmsghdr nlh = {
		.nlmsg_type = nlmsgtype,
		.nlmsg_flags = flags,
	};

	msg = nlmsg_inherit(&nlh);
	if (msg)
		NL_DBG(2, "msg %p: Allocated new simple message\n", msg);

	return msg;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movq 0x6bc2(%rip), %rdi      # 0xb328
callq 0x46b1
testq %rax, %rax
je 0x4784
movq 0x30(%rax), %rcx
movw %bp, 0x4(%rcx)
movw %bx, 0x6(%rcx)
movq $0x0, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_free
void nlmsg_free(struct nl_msg *msg)
{
	if (!msg)
		return;

	msg->nm_refcnt--;
	NL_DBG(4, "Returned message reference %p, %d remaining\n",
	       msg, msg->nm_refcnt);

	if (msg->nm_refcnt < 0)
		BUG();

	if (msg->nm_refcnt <= 0) {
		free(msg->nm_nlh);
		free(msg);
		NL_DBG(2, "msg %p: Freed\n", msg);
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4807
movq %rdi, %rbx
movl 0x40(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rdi)
testl %eax, %eax
jle 0x4809
cmpl $0x1, %eax
jne 0x4807
movq 0x30(%rbx), %rdi
callq 0x3060
movq %rbx, %rdi
popq %rbx
jmp 0x3060
popq %rbx
retq
callq 0x3692
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_reserve
void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
{
	void *buf = n->nm_nlh;
	size_t nlmsg_len = n->nm_nlh->nlmsg_len;
	size_t tlen;

	tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;

	if ((tlen + nlmsg_len) > n->nm_size)
		return NULL;

	buf += nlmsg_len;
	n->nm_nlh->nlmsg_len += tlen;

	if (tlen > len)
		memset(buf + len, 0, tlen - len);

	NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
		  n, len, pad, n->nm_nlh->nlmsg_len);

	return buf;
}

// Assembly:
pushq %rbx
movl %edx, %eax
movq 0x30(%rdi), %rcx
movl (%rcx), %ebx
movq %rsi, %rdx
testl %eax, %eax
je 0x4830
movslq %eax, %rdx
leaq (%rdx,%rsi), %r8
decq %r8
negl %eax
movslq %eax, %rdx
andq %r8, %rdx
leaq (%rdx,%rbx), %rax
cmpq 0x38(%rdi), %rax
jbe 0x483e
xorl %ebx, %ebx
jmp 0x4859
movl %ebx, %eax
addq %rcx, %rbx
addl %edx, %eax
movl %eax, (%rcx)
subq %rsi, %rdx
jbe 0x4859
addq %rbx, %rsi
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3200
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_put
struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
			   int type, int payload, int flags)
{
	struct nlmsghdr *nlh;

	if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
		BUG();

	nlh = (struct nlmsghdr *) n->nm_nlh;
	nlh->nlmsg_type = type;
	nlh->nlmsg_flags = flags;
	nlh->nlmsg_pid = pid;
	nlh->nlmsg_seq = seq;

	NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
		  "seq=%d\n", n, type, flags, pid, seq);

	if (payload > 0 &&
	    nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
		return NULL;

	return nlh;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
movq 0x30(%rdi), %rbx
movl (%rbx), %edi
cmpq $0xf, %rdi
jbe 0x48fc
movw %cx, 0x4(%rbx)
movw %r9w, 0x6(%rbx)
movl %esi, 0xc(%rbx)
movl %edx, 0x8(%rbx)
testl %r8d, %r8d
jle 0x48f3
leal 0x3(%r8), %edx
andl $-0x4, %edx
leaq (%rdx,%rdi), %r14
movq 0x38(%rax), %r15
cmpq %r15, %r14
ja 0x48f1
movl %r8d, %eax
leal (%rdx,%rdi), %ecx
movl %ecx, (%rbx)
subq %rax, %rdx
jbe 0x48ec
addq %rbx, %rdi
addq %rax, %rdi
xorl %esi, %esi
callq 0x3200
cmpq %r15, %r14
jbe 0x48f3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x36d5
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/msg.c
// Function: nl_msg_parse
int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
		 void *arg)
{
	struct nl_cache_ops *ops;
	struct nl_parser_param p = {
		.pp_cb = parse_cb
	};
	struct dp_xdata x = {
		.cb = cb,
		.arg = arg,
	};

	ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
				     nlmsg_hdr(msg)->nlmsg_type);
	if (ops == NULL)
		return -NLE_MSGTYPE_NOSUPPORT;
	p.pp_arg = &x;

	return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups 0x63e0(%rip), %xmm0     # 0xacf0
movaps %xmm0, 0x10(%rsp)
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movl (%rdi), %edi
movq 0x30(%rbx), %rax
movzwl 0x4(%rax), %esi
callq 0x3520
testq %rax, %rax
je 0x494e
movq %rsp, %rdx
leaq 0x10(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x30(%rbx), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x34a0
jmp 0x4953
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_ok
int nla_ok(const struct nlattr *nla, int remaining)
{
	size_t r = remaining;

	return r >= sizeof(*nla) &&
	       nla->nla_len >= sizeof(*nla) &&
	       nla->nla_len <= r;
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %esi
jb 0x4983
movzwl (%rdi), %ecx
cmpq $0x4, %rcx
jb 0x4983
movslq %esi, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_parse
int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
	      struct nla_policy *policy)
{
	struct nlattr *nla;
	int rem, err;

	memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));

	nla_for_each_attr(nla, head, len, rem) {
		int type = nla_type(nla);

		if (type == 0) {
			fprintf(stderr, "Illegal nla->nla_type == 0\n");
			continue;
		}

		if (type <= maxtype) {
			if (policy) {
				err = validate_nla(nla, maxtype, policy);
				if (err < 0)
					goto errout;
			}

			tb[type] = nla;
		}
	}

	if (rem > 0)
		fprintf(stderr, "netlink: %d bytes leftover after parsing "
		       "attributes.\n", rem);

	err = 0;
errout:
	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, (%rsp)
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %r12d
movslq %esi, %rax
leaq 0x8(,%rax,8), %rdx
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0x3200
cmpl $0x4, %ebx
jb 0x4a8e
movl $0x4, %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
leaq 0x2720(%rip), %rbp      # 0x7100
movq (%rsp), %rdx
movzwl (%r15), %eax
cmpq $0x4, %rax
jb 0x4a8e
movslq %ebx, %rcx
cmpq %rcx, %rax
ja 0x4a8e
movzwl 0x2(%r15), %r14d
andl $0x3fff, %r14d          # imm = 0x3FFF
je 0x4a6c
xorl %r13d, %r13d
cmpl %r12d, %r14d
jg 0x4a45
testq %rdx, %rdx
je 0x4a32
movq %r15, %rdi
movl %r12d, %esi
movq (%rsp), %rdx
callq 0x4ac6
movq (%rsp), %rdx
xorl %esi, %esi
testl %eax, %eax
js 0x4a3d
movq 0x10(%rsp), %rax
movq %r15, (%rax,%r14,8)
jmp 0x4a45
movl $0x5, %r13d
movl %eax, %esi
movl %r13d, %eax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movzwl (%r15), %eax
addl $0x3, %eax
andl $-0x4, %eax
subl %eax, %ebx
addq %rax, %r15
cmpl $0x3, %ebx
ja 0x49e4
jmp 0x4a8e
movl %esi, %r14d
callq 0x3718
movl %r14d, %esi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl %esi, %ebp
jmp 0x4a97
testl %ebx, %ebx
movl $0x0, %ebp
jg 0x4aa8
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6549(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x2695(%rip), %rsi      # 0x714e
xorl %ebp, %ebp
movl %ebx, %edx
xorl %eax, %eax
callq 0x3290
jmp 0x4a97
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: validate_nla
static int validate_nla(struct nlattr *nla, int maxtype,
			struct nla_policy *policy)
{
	struct nla_policy *pt;
	int minlen = 0, type = nla_type(nla);

	if (type <= 0 || type > maxtype)
		return 0;

	pt = &policy[type];

	if (pt->type > NLA_TYPE_MAX)
		BUG();

	if (pt->minlen)
		minlen = pt->minlen;
	else if (pt->type != NLA_UNSPEC)
		minlen = nla_attr_minlen[pt->type];

	if (pt->type == NLA_FLAG && nla_len(nla) > 0)
		return -NLE_RANGE;

	if (nla_len(nla) < minlen)
		return -NLE_RANGE;

	if (pt->maxlen && nla_len(nla) > pt->maxlen)
		return -NLE_RANGE;

	if (pt->type == NLA_STRING) {
		char *data = nla_data(nla);
		if (data[nla_len(nla) - 1] != '\0')
			return -NLE_INVAL;
	}

	return 0;
}

// Assembly:
movzwl 0x2(%rdi), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
sete %r8b
cmpl %esi, %ecx
setg %sil
xorl %eax, %eax
orb %r8b, %sil
jne 0x4b5c
leaq (%rcx,%rcx,2), %rax
movzwl (%rdx,%rax,2), %ecx
cmpq $0x9, %rcx
jae 0x4b5d
leaq (%rdx,%rax,2), %rdx
movzwl 0x2(%rdx), %esi
testw %si, %si
jne 0x4b10
testq %rcx, %rcx
je 0x4b0e
leaq 0x2618(%rip), %rax      # 0x7120
movzwl (%rax,%rcx,2), %esi
jmp 0x4b10
xorl %esi, %esi
cmpl $0x6, %ecx
jne 0x4b20
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
cmpw $0x4, (%rdi)
ja 0x4b5c
movzwl %si, %r8d
movzwl (%rdi), %esi
addq $-0x4, %rsi
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
cmpl %r8d, %esi
jl 0x4b5c
movzwl 0x4(%rdx), %edx
testl %edx, %edx
setne %r8b
cmpl %edx, %esi
setg %dl
testb %dl, %r8b
jne 0x4b5c
cmpl $0x5, %ecx
jne 0x4b5a
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
cmpb $0x0, 0x3(%rdi,%rsi)
jne 0x4b5c
xorl %eax, %eax
retq
pushq %rax
callq 0x3734
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_validate
int nla_validate(struct nlattr *head, int len, int maxtype,
		 struct nla_policy *policy)
{
	struct nlattr *nla;
	int rem, err;

	nla_for_each_attr(nla, head, len, rem) {
		err = validate_nla(nla, maxtype, policy);
		if (err < 0)
			goto errout;
	}

	err = 0;
errout:
	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x4, %esi
jb 0x4bbc
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
movzwl (%r12), %eax
cmpq $0x4, %rax
jb 0x4bbc
movslq %r15d, %rcx
cmpq %rcx, %rax
ja 0x4bbc
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4ac6
testl %eax, %eax
js 0x4bba
movzwl (%r12), %eax
addl $0x3, %eax
andl $-0x4, %eax
subl %eax, %r15d
addq %rax, %r12
cmpl $0x3, %r15d
ja 0x4b7d
jmp 0x4bbc
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_find
struct nlattr *nla_find(struct nlattr *head, int len, int attrtype)
{
	struct nlattr *nla;
	int rem;

	nla_for_each_attr(nla, head, len, rem)
		if (nla_type(nla) == attrtype)
			return nla;

	return NULL;
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %esi
jb 0x4c00
movzwl (%rdi), %ecx
cmpq $0x4, %rcx
jb 0x4c00
movslq %esi, %r8
cmpq %r8, %rcx
ja 0x4c00
movzwl 0x2(%rdi), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
cmpl %edx, %ecx
je 0x4c01
movzwl (%rdi), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
subl %ecx, %esi
addq %rcx, %rdi
cmpl $0x3, %esi
ja 0x4bce
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_reserve
struct nlattr *nla_reserve(struct nl_msg *msg, int attrtype, int attrlen)
{
	struct nlattr *nla;
	int tlen;
	
	tlen = NLMSG_ALIGN(msg->nm_nlh->nlmsg_len) + nla_total_size(attrlen);

	if ((tlen + msg->nm_nlh->nlmsg_len) > msg->nm_size)
		return NULL;

	nla = (struct nlattr *) nlmsg_tail(msg->nm_nlh);
	nla->nla_type = attrtype;
	nla->nla_len = nla_attr_size(attrlen);

	memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
	msg->nm_nlh->nlmsg_len = tlen;

	NL_DBG(2, "msg %p: Reserved %d bytes at offset +%td for attr %d "
		  "nlmsg_len=%d\n", msg, attrlen,
		  (void *) nla - nlmsg_data(msg->nm_nlh),
		  attrtype, msg->nm_nlh->nlmsg_len);

	return nla;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
movl (%rcx), %r8d
leal 0x3(%r8), %edi
andl $-0x4, %edi
leal 0x7(%rdx), %eax
andl $-0x4, %eax
leal (%rdi,%rax), %ebp
addl %ebp, %r8d
cmpq %r8, 0x38(%rbx)
jae 0x4c31
xorl %r14d, %r14d
jmp 0x4c5c
leaq (%rcx,%rdi), %r14
movw %si, 0x2(%rcx,%rdi)
leal 0x4(%rdx), %esi
movw %si, (%rcx,%rdi)
movzwl %si, %edi
addq %r14, %rdi
subl %edx, %eax
addl $-0x4, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x3200
movq 0x30(%rbx), %rax
movl %ebp, (%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/attr.c
// Function: nla_put
int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data)
{
	struct nlattr *nla;

	nla = nla_reserve(msg, attrtype, datalen);
	if (!nla)
		return -NLE_NOMEM;

	memcpy(nla_data(nla), data, datalen);
	NL_DBG(2, "msg %p: Wrote %d bytes at offset +%td for attr %d\n",
	       msg, datalen, (void *) nla - nlmsg_data(msg->nm_nlh), attrtype);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
callq 0x35b0
testq %rax, %rax
je 0x4c8c
addq $0x4, %rax
movslq %ebp, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32e0
xorl %eax, %eax
jmp 0x4c91
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_alloc
struct nl_cache *nl_cache_alloc(struct nl_cache_ops *ops)
{
	struct nl_cache *cache;

	cache = calloc(1, sizeof(*cache));
	if (!cache)
		return NULL;

	nl_init_list_head(&cache->c_items);
	cache->c_ops = ops;

	NL_DBG(2, "Allocated cache %p <%s>.\n", cache, nl_cache_name(cache));

	return cache;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x3270
testq %rax, %rax
je 0x4cbd
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, 0x20(%rax)
jmp 0x4cbf
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_alloc_and_fill
int nl_cache_alloc_and_fill(struct nl_cache_ops *ops, struct nl_sock *sock,
			    struct nl_cache **result)
{
	struct nl_cache *cache;
	int err;
	
	if (!(cache = nl_cache_alloc(ops)))
		return -NLE_NOMEM;

	if (sock && (err = nl_cache_refill(sock, cache)) < 0) {
		nl_cache_free(cache);
		return err;
	}

	*result = cache;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x28, %esi
callq 0x3270
testq %rax, %rax
je 0x4cf6
movq %rax, %r14
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %r12, 0x20(%rax)
jmp 0x4cf9
xorl %r14d, %r14d
testq %r14, %r14
je 0x4d19
testq %r15, %r15
je 0x4d12
movq %r15, %rdi
movq %r14, %rsi
callq 0x35e0
testl %eax, %eax
js 0x4d20
movq %r14, (%rbx)
xorl %ebp, %ebp
jmp 0x4d2a
movl $0xfffffffb, %ebp       # imm = 0xFFFFFFFB
jmp 0x4d2a
movl %eax, %ebp
movq %r14, %rdi
callq 0x3050
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_refill
int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache)
{
	int err;

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

	NL_DBG(2, "Upading cache %p <%s>, request sent, waiting for dump...\n",
	       cache, nl_cache_name(cache));
	nl_cache_clear(cache);

	return nl_cache_pickup(sk, cache);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x4d5b
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
jmp 0x4d60
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
testl %eax, %eax
js 0x4d9c
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x4d80
movq (%rdi), %r15
addq $-0x18, %rdi
callq 0x33b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x4d6c
leaq 0x1de(%rip), %rax       # 0x4f65
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rbx, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3130
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_free
void nl_cache_free(struct nl_cache *cache)
{
	if (!cache)
		return;

	nl_cache_clear(cache);
	NL_DBG(1, "Freeing cache %p <%s>...\n", cache, nl_cache_name(cache));
	free(cache);
}

// Assembly:
testq %rdi, %rdi
je 0x4ddd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rbx, %rdi
je 0x4dce
movq (%rdi), %r14
addq $-0x18, %rdi
callq 0x33b0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x4dba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_remove
void nl_cache_remove(struct nl_object *obj)
{
	struct nl_cache *cache = obj->ce_cache;

	if (cache == NULL)
		return;

	nl_list_del(&obj->ce_list);
	obj->ce_cache = NULL;
	nl_object_put(obj);
	cache->c_nitems--;

	NL_DBG(1, "Deleted %p from cache %p <%s>.\n",
	       obj, cache, nl_cache_name(cache));
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x4e47
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rdi), %rcx
movq %rax, (%rcx)
movq $0x0, 0x10(%rdi)
testq %rdi, %rdi
je 0x4e44
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jg 0x4e44
callq 0x3110
decl 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_add
int nl_cache_add(struct nl_cache *cache, struct nl_object *obj)
{
	struct nl_object *new;

	if (cache->c_ops->co_obj_ops != obj->ce_ops)
		return -NLE_OBJ_MISMATCH;

	if (!nl_list_empty(&obj->ce_list)) {
		new = nl_object_clone(obj);
		if (!new)
			return -NLE_NOMEM;
	} else {
		nl_object_get(obj);
		new = obj;
	}

	return __cache_add(cache, new);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rcx
movl $0xffffffe9, %eax       # imm = 0xFFFFFFE9
cmpq 0x8(%rsi), %rcx
jne 0x4ea3
movq %rdi, %rbx
leaq 0x18(%rsi), %rax
cmpq %rax, 0x18(%rsi)
je 0x4e81
movq %rsi, %rdi
callq 0x33a0
movq %rax, %rsi
testq %rax, %rax
jne 0x4e83
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x4ea3
incl (%rsi)
movq %rbx, 0x10(%rsi)
leaq 0x18(%rsi), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x20(%rsi)
movq %rax, 0x8(%rbx)
movq %rbx, 0x18(%rsi)
incl 0x10(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: _cache_pickup
int __cache_pickup(struct nl_sock *sk, struct nl_cache *cache,
		   struct nl_parser_param *param)
{
	int err;
	struct nl_cb *cb;
	struct update_xdata x = {
		.ops = cache->c_ops,
		.params = param,
	};

	NL_DBG(1, "Picking up answer for cache %p <%s>...\n",
		  cache, nl_cache_name(cache));

	cb = nl_cb_clone(sk->s_cb);
	if (cb == NULL)
		return -NLE_NOMEM;

	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, update_msg_parser, &x);

	err = nl_recvmsgs(sk, cb);
	if (err < 0)
		NL_DBG(2, "While picking up for %p <%s>, recvmsgs() returned " \
		       "%d: %s", cache, nl_cache_name(cache),
		       err, nl_geterror(err));

	nl_cb_put(cb);

	return err;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x30(%rdi), %rdi
callq 0x33e0
testq %rax, %rax
je 0x4f1e
movq %rax, %r14
leaq 0x3a(%rip), %rcx        # 0x4f2d
leaq 0x8(%rsp), %r8
movq %rax, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x35f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movl %eax, %ebx
movq %r14, %rdi
callq 0x32b0
jmp 0x4f23
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_parse
int nl_cache_parse(struct nl_cache_ops *ops, struct sockaddr_nl *who,
		   struct nlmsghdr *nlh, struct nl_parser_param *params)
{
	int i, err;

	if (!nlmsg_valid_hdr(nlh, ops->co_hdrsize))
		return -NLE_MSG_TOOSHORT;

	for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++) {
		if (ops->co_msgtypes[i].mt_id == nlh->nlmsg_type) {
			err = ops->co_msg_parser(ops, who, nlh, params);
			if (err != -NLE_OPNOTSUPP)
				goto errout;
		}
	}


	err = -NLE_MSGTYPE_NOSUPPORT;
errout:
	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
addl $0x10, %eax
movl $0xffffffeb, %ebp       # imm = 0xFFFFFFEB
cmpl %eax, (%rdx)
jb 0x4fda
movq %rdi, %r12
movl 0x48(%rdi), %eax
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
testl %eax, %eax
js 0x4fda
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x58(%r12), %r13
movzwl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x4fca
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x20(%r12)
cmpl $-0xa, %eax
jne 0x4fd8
movl (%r13), %eax
addq $0x10, %r13
testl %eax, %eax
jns 0x4fab
jmp 0x4fda
movl %eax, %ebp
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_O1/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_parse_and_add
int nl_cache_parse_and_add(struct nl_cache *cache, struct nl_msg *msg)
{
	struct nl_parser_param p = {
		.pp_cb = pickup_cb,
		.pp_arg = cache,
	};

	return nl_cache_parse(cache->c_ops, NULL, nlmsg_hdr(msg), &p);
}

// Assembly:
subq $0x18, %rsp
leaq -0x91(%rip), %rax       # 0x4f65
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rdi, 0x8(%rcx)
movq 0x20(%rdi), %rdi
movq 0x30(%rsi), %rdx
xorl %esi, %esi
callq 0x34a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache_mngt.c
// Function: nl_cache_ops_associate
struct nl_cache_ops *nl_cache_ops_associate(int protocol, int msgtype)
{
	int i;
	struct nl_cache_ops *ops;

	for (ops = cache_ops; ops; ops = ops->co_next) {
		if (ops->co_protocol != protocol)
			continue;

		for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
			if (ops->co_msgtypes[i].mt_id == msgtype)
				return ops;
	}

	return NULL;
}

// Assembly:
movq 0x6551(%rip), %rax      # 0xb5a8
testq %rax, %rax
je 0x5080
cmpl %edi, 0xc(%rax)
jne 0x507a
movl 0x48(%rax), %ecx
testl %ecx, %ecx
js 0x507a
leaq 0x58(%rax), %rdx
cmpl %esi, %ecx
je 0x5082
movl (%rdx), %ecx
addq $0x10, %rdx
testl %ecx, %ecx
jns 0x506c
movq 0x30(%rax), %rax
jmp 0x5057
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/cache_mngt.c
// Function: nl_cache_mngt_register
int nl_cache_mngt_register(struct nl_cache_ops *ops)
{
	if (!ops->co_name || !ops->co_obj_ops)
		return -NLE_INVAL;

	if (nl_cache_ops_lookup(ops->co_name))
		return -NLE_EXIST;

	ops->co_next = cache_ops;
	cache_ops = ops;

	NL_DBG(1, "Registered cache operations %s\n", ops->co_name);

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
testq %rdi, %rdi
je 0x50c1
cmpq $0x0, 0x28(%rbx)
je 0x50c1
callq 0x3480
movq %rax, %rcx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testq %rcx, %rcx
jne 0x50c1
movq 0x64f4(%rip), %rax      # 0xb5a8
movq %rax, 0x30(%rbx)
movq %rbx, 0x64e9(%rip)      # 0xb5a8
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/object.c
// Function: nl_object_alloc
struct nl_object *nl_object_alloc(struct nl_object_ops *ops)
{
	struct nl_object *new;

	if (ops->oo_size < sizeof(*new))
		BUG();

	new = calloc(1, ops->oo_size);
	if (!new)
		return NULL;

	new->ce_refcnt = 1;
	nl_init_list_head(&new->ce_list);

	new->ce_ops = ops;
	if (ops->oo_constructor)
		ops->oo_constructor(new);

	NL_DBG(4, "Allocated new object %p\n", new);

	return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rsi
cmpq $0x37, %rsi
jbe 0x514a
movq %rdi, %r14
movl $0x1, %edi
callq 0x3270
testq %rax, %rax
je 0x513d
movq %rax, %rbx
movl $0x1, (%rax)
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %r14, 0x8(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x513f
movq %rbx, %rdi
callq *%rax
jmp 0x513f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3777
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/object.c
// Function: nl_object_clone
struct nl_object *nl_object_clone(struct nl_object *obj)
{
	struct nl_object *new;
	struct nl_object_ops *ops = obj_ops(obj);
	int doff = offsetof(struct nl_derived_object, data);
	int size;

	new = nl_object_alloc(ops);
	if (!new)
		return NULL;

	size = ops->oo_size - doff;
	if (size < 0)
		BUG();

	new->ce_ops = obj->ce_ops;
	new->ce_msgtype = obj->ce_msgtype;

	if (size)
		memcpy((void *)new + doff, (void *)obj + doff, size);

	if (ops->oo_clone) {
		if (ops->oo_clone(new, obj) < 0) {
			nl_object_free(new);
			return NULL;
		}
	} else if (size && ops->oo_free_data)
		BUG();

	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x51d8
movq %rdi, %r15
movq %r14, %rdi
callq 0x3240
testq %rax, %rax
je 0x51bb
movl 0x8(%r14), %ebp
addl $-0x34, %ebp
js 0x51dd
movq %rax, %rbx
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
je 0x519e
movq %rbx, %rdi
addq $0x34, %rdi
leaq 0x34(%r15), %rsi
movl %ebp, %edx
callq 0x32e0
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x51bf
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jns 0x51ca
movq %rbx, %rdi
callq 0x3110
xorl %ebx, %ebx
jmp 0x51ca
testl %ebp, %ebp
je 0x51ca
cmpq $0x0, 0x20(%r14)
jne 0x51e2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x383d
callq 0x37fb
callq 0x37b9
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/object.c
// Function: nl_object_free
void nl_object_free(struct nl_object *obj)
{
	struct nl_object_ops *ops = obj_ops(obj);

	if (obj->ce_refcnt > 0)
		NL_DBG(1, "Warning: Freeing object in use...\n");

	if (obj->ce_cache)
		nl_cache_remove(obj);

	if (ops->oo_free_data)
		ops->oo_free_data(obj);

	free(obj);

	NL_DBG(4, "Freed object %p\n", obj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x5223
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x5206
movq %rbx, %rdi
callq 0x33b0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x5214
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
callq 0x387f
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/socket.c
// Function: _alloc_socket
static struct nl_sock *__alloc_socket(struct nl_cb *cb)
{
	struct nl_sock *sk;

	sk = calloc(1, sizeof(*sk));
	if (!sk)
		return NULL;

	sk->s_fd = -1;
	sk->s_cb = cb;
	sk->s_local.nl_family = AF_NETLINK;
	sk->s_peer.nl_family = AF_NETLINK;
	sk->s_seq_expect = sk->s_seq_next = time(0);
	sk->s_local.nl_pid = generate_local_port();
	if (sk->s_local.nl_pid == UINT_MAX) {
		nl_socket_free(sk);
		return NULL;
	}

	return sk;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x3270
testq %rax, %rax
je 0x5295
movq %rax, %rbx
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq %r14, 0x30(%rax)
movw $0x10, %ax
movw %ax, (%rbx)
movw %ax, 0xc(%rbx)
xorl %edi, %edi
callq 0x3320
movl %eax, 0x20(%rbx)
movl %eax, 0x24(%rbx)
callq 0x5376
movl %eax, 0x4(%rbx)
cmpl $-0x1, %eax
jne 0x5297
movq %rbx, %rdi
callq 0x34f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_free
void nl_socket_free(struct nl_sock *sk)
{
	if (!sk)
		return;

	if (sk->s_fd >= 0)
		close(sk->s_fd);

	if (!(sk->s_flags & NL_OWN_PORT))
		release_local_port(sk->s_local.nl_pid);

	nl_cb_put(sk->s_cb);
	free(sk);
}

// Assembly:
testq %rdi, %rdi
je 0x5308
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %edi
testl %edi, %edi
js 0x52ca
callq 0x3230
testb $0x4, 0x28(%rbx)
jne 0x52f6
movl 0x4(%rbx), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x52f6
movl %eax, %ecx
shrl $0x16, %ecx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
roll %cl, %edx
shrl $0x1b, %eax
leaq 0x62bd(%rip), %rcx      # 0xb5b0
andl %edx, (%rcx,%rax,4)
movq 0x30(%rbx), %rdi
callq 0x32b0
movq %rbx, %rdi
popq %rbx
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_set_local_port
void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
{
	if (port == 0) {
		port = generate_local_port(); 
		sk->s_flags &= ~NL_OWN_PORT;
	} else  {
		if (!(sk->s_flags & NL_OWN_PORT))
			release_local_port(sk->s_local.nl_pid);
		sk->s_flags |= NL_OWN_PORT;
	}

	sk->s_local.nl_pid = port;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x5366
movl 0x28(%rbx), %eax
testb $0x4, %al
jne 0x535e
movl 0x4(%rbx), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rdx
je 0x535e
movl %edx, %ecx
shrl $0x16, %ecx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
roll %cl, %edi
shrl $0x1b, %edx
leaq 0x6255(%rip), %rcx      # 0xb5b0
andl %edi, (%rcx,%rdx,4)
orl $0x4, %eax
movl %eax, 0x28(%rbx)
jmp 0x5371
callq 0x5376
movl %eax, %esi
andb $-0x5, 0x28(%rbx)
movl %esi, 0x4(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/socket.c
// Function: generate_local_port
static uint32_t generate_local_port(void)
{
	int i, n;
	uint32_t pid = getpid() & 0x3FFFFF;

	for (i = 0; i < 32; i++) {
		if (used_ports_map[i] == 0xFFFFFFFF)
			continue;

		for (n = 0; n < 32; n++) {
			if (1UL & (used_ports_map[i] >> n))
				continue;

			used_ports_map[i] |= (1UL << n);
			n += (i * 32);

			/* PID_MAX_LIMIT is currently at 2^22, leaving 10 bit
			 * to, i.e. 1024 unique ports per application. */
			return pid + (n << 22);

		}
	}

	/* Out of sockets in our own PID namespace, what to do? FIXME */
	return UINT_MAX;
}

// Assembly:
pushq %rax
callq 0x3150
andl $0x3fffff, %eax         # imm = 0x3FFFFF
xorl %esi, %esi
leaq 0x6226(%rip), %rdi      # 0xb5b0
movl (%rdi,%rsi,4), %r8d
cmpl $-0x1, %r8d
je 0x53ac
xorl %ecx, %ecx
movl %eax, %edx
btl %ecx, %r8d
jae 0x53c1
addl $0x400000, %edx         # imm = 0x400000
incq %rcx
cmpl $0x20, %ecx
jne 0x5398
incq %rsi
addl $0x8000000, %eax        # imm = 0x8000000
cmpq $0x20, %rsi
jne 0x538a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x53d0
movl $0x1, %eax
shlq %cl, %rax
orl %eax, %r8d
movl %r8d, (%rdi,%rsi,4)
movl %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_add_memberships
int nl_socket_add_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_ADD_MEMBERSHIP,
						 &group, sizeof(group));
		if (err < 0)
			return -nl_syserr2nlerr(errno);

		group = va_arg(ap, int);
	}

	va_end(ap);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
testb %al, %al
je 0x541c
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
movl %esi, 0xc(%rsp)
cmpl $-0x1, 0x18(%rdi)
je 0x54ce
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x54ca
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
testl %eax, %eax
js 0x54d5
movl 0x18(%rbx), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x1, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x54dc
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x54b2
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x54c0
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
jne 0x5474
xorl %eax, %eax
jmp 0x54ea
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x54ea
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
jmp 0x54ea
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xe8, %rsp
testb %al, %al
je 0x553d
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
movl %esi, 0xc(%rsp)
cmpl $-0x1, 0x18(%rdi)
je 0x55ef
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x55eb
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
testl %eax, %eax
js 0x55f6
movl 0x18(%rbx), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x55fd
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x55d3
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x55e1
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
jne 0x5595
xorl %eax, %eax
jmp 0x560b
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x560b
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
jmp 0x560b
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
testl %esi, %esi
jg 0x566d
movl $0x8000, 0xc(%rsp)      # imm = 0x8000
testl %edx, %edx
jg 0x5679
movl $0x8000, 0x8(%rsp)      # imm = 0x8000
movl 0x18(%rbx), %edi
cmpl $-0x1, %edi
je 0x56d8
leaq 0x8(%rsp), %rcx
movl $0x1, %esi
movl $0x7, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x56c8
movl 0x18(%rbx), %edi
leaq 0xc(%rsp), %rcx
movl $0x1, %esi
movl $0x8, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x56c8
orb $0x1, 0x28(%rbx)
xorl %eax, %eax
jmp 0x56dd
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x56dd
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl 0x18(%rdi), %edi
cmpl $-0x1, %edi
je 0x5724
leaq 0xc(%rsp), %rcx
movl $0x1, %esi
movl $0x10, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x572b
cmpl $0x0, 0xc(%rsp)
movl 0x28(%rbx), %eax
je 0x573b
orl $0x2, %eax
jmp 0x573e
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x5743
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x5743
andl $-0x3, %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl %esi, 0x4(%rsp)
movl 0x18(%rdi), %edi
cmpl $-0x1, %edi
je 0x5788
leaq 0x4(%rsp), %rcx
movl $0x10e, %esi            # imm = 0x10E
movl $0x3, %edx
movl $0x4, %r8d
callq 0x3120
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x578d
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x578d
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edi, %ecx
negl %ecx
cmovsl %edi, %ecx
movl $0x3, %eax
leal -0x1(%rcx), %edx
cmpl $0x21, %edx
ja 0x57f1
leaq 0x1ace(%rip), %rcx      # 0x72b0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl $0xc, %eax
retq
addl $-0x58, %ecx
cmpl $0x11, %ecx
ja 0x5845
leaq 0x1b38(%rip), %rdx      # 0x7338
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x7, %eax
retq
movl $0x5, %eax
retq
movl $0x6, %eax
retq
movl $0x2, %eax
retq
movl $0x1c, %eax
retq
movl $0x1b, %eax
retq
movl $0x19, %eax
retq
movl $0x4, %eax
retq
movl $0x8, %eax
retq
movl $0x1f, %eax
retq
movl $0x1, %eax
retq
movl $0xb, %eax
retq
movl $0x1a, %eax
retq
movl $0xa, %eax
retq
movl $0x13, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x3270
testq %rax, %rax
je 0x59e6
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movq %rax, %rcx
addq $0x8, %rcx
leaq 0x58(%rbx), %rdx
movq 0x60(%rbx), %rsi
movq %rcx, (%rsi)
movq %rsi, 0x10(%rax)
movq %rcx, 0x60(%rbx)
movq %rdx, 0x8(%rax)
orb $0x20, 0x30(%rbx)
xorl %eax, %eax
jmp 0x59eb
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3270
testq %rax, %rax
je 0x5a51
movq %rax, %r14
movl %ebp, 0x28(%rax)
leaq 0x18(%rax), %rdi
movl $0xf, %edx
movq %r15, %rsi
callq 0x30a0
movb $0x0, 0x27(%r14)
movq %r14, %rax
addq $0x8, %rax
leaq 0x68(%rbx), %rcx
movq 0x70(%rbx), %rdx
movq %rax, (%rdx)
movq %rdx, 0x10(%r14)
movq %rax, 0x70(%rbx)
movq %rcx, 0x8(%r14)
xorl %eax, %eax
jmp 0x5a56
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5aec
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x58(%rdi), %rax
cmpq %r14, %rax
je 0x5ab7
leaq -0x8(%rax), %rdi
movq (%rax), %r15
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r15)
movq 0x8(%rax), %rax
movq %r15, (%rax)
callq 0x3060
movq %r15, %rax
cmpq %r14, %r15
jne 0x5a94
movq 0x68(%rbx), %rax
addq $0x68, %rbx
cmpq %rbx, %rax
je 0x5ae7
leaq -0x8(%rax), %rdi
movq (%rax), %r14
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq 0x8(%rax), %rax
movq %r14, (%rax)
callq 0x3060
movq %r14, %rax
cmpq %rbx, %r14
jne 0x5ac4
popq %rbx
popq %r14
popq %r15
retq