LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x45f4
movl $0x1, 0x40(%rbx)
movq %r14, %rdi
callq 0x3380
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x45f4
movl $0x0, 0xc(%rax)
movq $0x0, 0x4(%rax)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq %r14, 0x38(%rbx)
movl $0x10, (%rax)
jmp 0x45fe
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_O3/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 0x6d12(%rip), %rdi      # 0xb328
callq 0x459d
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x463d
movq 0x30(%rax), %rcx
movl 0x4(%rbx), %edx
movl %edx, 0x4(%rcx)
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6cdb(%rip), %rdi      # 0xb328
callq 0x459d
testq %rax, %rax
je 0x466b
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_O3/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 0x46e9
movq %rdi, %rbx
movl 0x40(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rdi)
testl %eax, %eax
jle 0x46eb
cmpl $0x1, %eax
jne 0x46e9
movq 0x30(%rbx), %rdi
callq 0x3060
movq %rbx, %rdi
popq %rbx
jmp 0x3060
popq %rbx
retq
callq 0x3692
// File: /workspace/github_c_makefile_star2_O3/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 0x4712
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 0x4720
xorl %ebx, %ebx
jmp 0x473b
movl %ebx, %eax
addq %rcx, %rbx
addl %edx, %eax
movl %eax, (%rcx)
subq %rsi, %rdx
jbe 0x473b
addq %rbx, %rsi
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3200
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rax
movq 0x30(%rdi), %rbx
movl (%rbx), %edi
cmpq $0xf, %rdi
jbe 0x47d0
movw %cx, 0x4(%rbx)
movw %r9w, 0x6(%rbx)
movl %esi, 0xc(%rbx)
movl %edx, 0x8(%rbx)
testl %r8d, %r8d
jle 0x47cb
leal 0x3(%r8), %edx
andl $-0x4, %edx
leaq (%rdx,%rdi), %rcx
cmpq 0x38(%rax), %rcx
jbe 0x47b1
xorl %ebx, %ebx
jmp 0x47cb
movl %r8d, %eax
leal (%rdx,%rdi), %ecx
movl %ecx, (%rbx)
subq %rax, %rdx
jbe 0x47cb
addq %rbx, %rdi
addq %rax, %rdi
xorl %esi, %esi
callq 0x3200
movq %rbx, %rax
popq %rbx
retq
callq 0x36d5
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x49(%rip), %rax        # 0x482d
movq %rax, 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 0x4822
movq %rsp, %rdx
leaq 0x10(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x30(%rbx), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x34a0
jmp 0x4827
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4857
movzwl (%rdi), %ecx
cmpq $0x4, %rcx
jb 0x4857
movslq %esi, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
movslq %esi, %rax
leaq 0x8(,%rax,8), %rdx
xorl %esi, %esi
callq 0x3200
cmpl $0x4, %ebx
jb 0x48f4
movzwl (%r15), %eax
cmpq $0x4, %rax
jb 0x48f4
movslq %ebx, %rcx
cmpq %rcx, %rax
ja 0x48f4
movzwl 0x2(%r15), %ebp
andl $0x3fff, %ebp           # imm = 0x3FFF
je 0x48ed
cmpl %r12d, %ebp
jg 0x48d7
testq %r14, %r14
je 0x48d2
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4930
testl %eax, %eax
js 0x490e
movq %r15, (%r13,%rbp,8)
movzwl (%r15), %eax
addl $0x3, %eax
andl $-0x4, %eax
subl %eax, %ebx
addq %rax, %r15
cmpl $0x3, %ebx
ja 0x4897
jmp 0x48f4
callq 0x3718
jmp 0x48d7
testl %ebx, %ebx
movl $0x0, %ebp
jg 0x4912
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x48fd
movq 0x66df(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x27f8(%rip), %rsi      # 0x711b
xorl %ebp, %ebp
movl %ebx, %edx
xorl %eax, %eax
callq 0x3290
jmp 0x48fd
// File: /workspace/github_c_makefile_star2_O3/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 0x4998
leaq (%rcx,%rcx,2), %rax
movzwl (%rdx,%rax,2), %ecx
cmpq $0x9, %rcx
jae 0x49de
leaq (%rdx,%rax,2), %rdx
movzwl 0x2(%rdx), %esi
testw %si, %si
jne 0x497a
testq %rcx, %rcx
je 0x4999
leaq 0x282a(%rip), %rax      # 0x71a0
movzwl (%rax,%rcx,2), %esi
cmpl $0x6, %ecx
sete %r9b
movzwl (%rdi), %r8d
cmpw $0x5, %r8w
setae %r10b
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
testb %r10b, %r9b
je 0x499f
retq
movzwl (%rdi), %r8d
xorl %esi, %esi
movzwl %si, %r9d
movzwl %r8w, %esi
addl $-0x4, %esi
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
cmpl %r9d, %esi
jl 0x4998
movzwl 0x4(%rdx), %edx
testl %edx, %edx
setne %r8b
cmpl %edx, %esi
seta %dl
testb %dl, %r8b
jne 0x4998
cmpl $0x5, %ecx
jne 0x49db
movl %esi, %ecx
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
cmpb $0x0, 0x3(%rdi,%rcx)
jne 0x4998
xorl %eax, %eax
retq
pushq %rax
callq 0x3734
// File: /workspace/github_c_makefile_star2_O3/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 0x4a3d
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
movzwl (%r12), %eax
cmpq $0x4, %rax
jb 0x4a3d
movslq %r15d, %rcx
cmpq %rcx, %rax
ja 0x4a3d
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4930
testl %eax, %eax
js 0x4a3b
movzwl (%r12), %eax
addl $0x3, %eax
andl $-0x4, %eax
subl %eax, %r15d
addq %rax, %r12
cmpl $0x3, %r15d
ja 0x49fe
jmp 0x4a3d
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4a81
movzwl (%rdi), %ecx
cmpq $0x4, %rcx
jb 0x4a81
movslq %esi, %r8
cmpq %r8, %rcx
ja 0x4a81
movzwl 0x2(%rdi), %r8d
andl $0x3fff, %r8d           # imm = 0x3FFF
cmpl %edx, %r8d
je 0x4a82
addl $0x3, %ecx
andl $-0x4, %ecx
subl %ecx, %esi
addq %rcx, %rdi
cmpl $0x3, %esi
ja 0x4a4f
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ab2
xorl %r14d, %r14d
jmp 0x4add
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_O3/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 0x4b0d
addq $0x4, %rax
movslq %ebp, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32e0
xorl %eax, %eax
jmp 0x4b12
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x4b8f
movq %rax, %r14
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %r12, 0x20(%rax)
testq %r15, %r15
je 0x4b88
movq %r15, %rdi
movq %r14, %rsi
callq 0x35e0
testl %eax, %eax
js 0x4b96
movq %r14, (%rbx)
xorl %ebp, %ebp
jmp 0x4ba0
movl $0xfffffffb, %ebp       # imm = 0xFFFFFFFB
jmp 0x4ba0
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_O3/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_refill
int nl_cache_request_full_dump(struct nl_sock *sk, struct nl_cache *cache)
{
	NL_DBG(2, "Requesting dump from kernel for cache %p <%s>...\n",
	          cache, nl_cache_name(cache));

	if (cache->c_ops->co_request_update == NULL)
		return -NLE_OPNOTSUPP;

	return cache->c_ops->co_request_update(cache, sk);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x4c0d
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
js 0x4c12
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x4bef
movq (%rdi), %r15
addq $-0x18, %rdi
callq 0x33b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x4bdb
leaq 0x1dc(%rip), %rax       # 0x4dd2
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rbx, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3130
jmp 0x4c12
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c53
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rbx, %rdi
je 0x4c44
movq (%rdi), %r14
addq $-0x18, %rdi
callq 0x33b0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x4c30
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4cb4
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq $0x0, 0x10(%rdi)
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jg 0x4cb1
callq 0x3110
decl 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d10
movq %rdi, %rbx
leaq 0x18(%rsi), %rax
cmpq %rax, 0x18(%rsi)
je 0x4cee
movq %rsi, %rdi
callq 0x33a0
movq %rax, %rsi
testq %rax, %rax
jne 0x4cf0
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x4d10
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_O3/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 0x4d8b
movq %rax, %r14
leaq 0x3a(%rip), %rcx        # 0x4d9a
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 0x4d90
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 (%rdx), %eax
ja 0x4e47
movq %rdi, %r12
movl 0x48(%rdi), %eax
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
testl %eax, %eax
js 0x4e47
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x58(%r12), %r13
movzwl 0x4(%r14), %ecx
cmpl %ecx, %eax
jne 0x4e37
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x20(%r12)
cmpl $-0xa, %eax
jne 0x4e45
movl (%r13), %eax
addq $0x10, %r13
testl %eax, %eax
jns 0x4e18
jmp 0x4e47
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_O3/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 0x66e5(%rip), %rax      # 0xb5a8
testq %rax, %rax
je 0x4eec
cmpl %edi, 0xc(%rax)
jne 0x4ee6
movl 0x48(%rax), %ecx
testl %ecx, %ecx
js 0x4ee6
leaq 0x58(%rax), %rdx
cmpl %esi, %ecx
je 0x4eee
movl (%rdx), %ecx
addq $0x10, %rdx
testl %ecx, %ecx
jns 0x4ed8
movq 0x30(%rax), %rax
jmp 0x4ec3
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f2d
cmpq $0x0, 0x28(%rbx)
je 0x4f2d
callq 0x3480
movq %rax, %rcx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
testq %rcx, %rcx
jne 0x4f2d
movq 0x6688(%rip), %rax      # 0xb5a8
movq %rax, 0x30(%rbx)
movq %rbx, 0x667d(%rip)      # 0xb5a8
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4fb6
movq %rdi, %rbx
movl $0x1, %edi
callq 0x3270
movq %rax, %r14
testq %rax, %rax
je 0x4fab
movl $0x1, (%r14)
movq %r14, %rax
addq $0x18, %rax
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rbx, 0x8(%r14)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4fab
movq %r14, %rdi
callq *%rax
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3777
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x5045
movq %rdi, %r14
movq %r15, %rdi
callq 0x3240
testq %rax, %rax
je 0x503a
movq %rax, %rbx
movl 0x8(%r15), %eax
addl $-0x34, %eax
js 0x504a
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movl 0x28(%r14), %ecx
movl %ecx, 0x28(%rbx)
je 0x501d
movq %rbx, %rdi
addq $0x34, %rdi
leaq 0x34(%r14), %rsi
movl %eax, %edx
callq 0x32e0
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x5026
cmpq $0x0, 0x20(%r15)
je 0x503c
callq 0x37b9
movq 0x28(%r15), %rax
testq %rax, %rax
je 0x503c
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jns 0x503c
movq %rbx, %rdi
callq 0x3110
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x383d
callq 0x37fb
// File: /workspace/github_c_makefile_star2_O3/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 0x508b
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x506e
movq %rbx, %rdi
callq 0x33b0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x507c
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_O3/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 0x50fd
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 0x51de
movl %eax, 0x4(%rbx)
cmpl $-0x1, %eax
jne 0x50ff
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_O3/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 0x5170
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %edi
testl %edi, %edi
js 0x5132
callq 0x3230
testb $0x4, 0x28(%rbx)
jne 0x515e
movl 0x4(%rbx), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x515e
movl %eax, %ecx
shrl $0x16, %ecx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
roll %cl, %edx
shrl $0x1b, %eax
leaq 0x6455(%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_O3/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 0x51ce
movl 0x28(%rbx), %eax
testb $0x4, %al
jne 0x51c6
movl 0x4(%rbx), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rdx
je 0x51c6
movl %edx, %ecx
shrl $0x16, %ecx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
roll %cl, %edi
shrl $0x1b, %edx
leaq 0x63ed(%rip), %rcx      # 0xb5b0
andl %edi, (%rcx,%rdx,4)
orl $0x4, %eax
movl %eax, 0x28(%rbx)
jmp 0x51d9
callq 0x51de
movl %eax, %esi
andb $-0x5, 0x28(%rbx)
movl %esi, 0x4(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x63be(%rip), %rdi      # 0xb5b0
movl (%rdi,%rsi,4), %r8d
cmpl $-0x1, %r8d
je 0x5214
xorl %ecx, %ecx
movl %eax, %edx
btl %ecx, %r8d
jae 0x5229
addl $0x400000, %edx         # imm = 0x400000
incq %rcx
cmpl $0x20, %ecx
jne 0x5200
incq %rsi
addl $0x8000000, %eax        # imm = 0x8000000
cmpq $0x20, %rsi
jne 0x51f2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x5238
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_O3/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 0x5284
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 0x5332
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)
testl %esi, %esi
je 0x532e
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
testl %esi, %esi
js 0x5339
movl 0x18(%rbx), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x1, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x5340
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x5316
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x5324
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %esi
movl %esi, 0xc(%rsp)
testl %esi, %esi
jne 0x52d8
xorl %eax, %eax
jmp 0x534e
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x534e
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
jmp 0x534e
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x53a1
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 0x544f
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)
testl %esi, %esi
je 0x544b
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
testl %esi, %esi
js 0x5456
movl 0x18(%rbx), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x545d
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x5433
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x5441
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %esi
movl %esi, 0xc(%rsp)
testl %esi, %esi
jne 0x53f5
xorl %eax, %eax
jmp 0x546b
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x546b
movl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
jmp 0x546b
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x54cd
movl $0x8000, 0xc(%rsp)      # imm = 0x8000
testl %edx, %edx
jg 0x54d9
movl $0x8000, 0x8(%rsp)      # imm = 0x8000
movl 0x18(%rbx), %edi
cmpl $-0x1, %edi
je 0x5538
leaq 0x8(%rsp), %rcx
movl $0x1, %esi
movl $0x7, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x5528
movl 0x18(%rbx), %edi
leaq 0xc(%rsp), %rcx
movl $0x1, %esi
movl $0x8, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x5528
orb $0x1, 0x28(%rbx)
xorl %eax, %eax
jmp 0x553d
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x553d
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5584
leaq 0xc(%rsp), %rcx
movl $0x1, %esi
movl $0x10, %edx
movl $0x4, %r8d
callq 0x3120
testl %eax, %eax
js 0x558b
cmpl $0x0, 0xc(%rsp)
movl 0x28(%rbx), %eax
je 0x559b
orl $0x2, %eax
jmp 0x559e
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x55a3
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x55a3
andl $-0x3, %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x55e8
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 0x55ed
callq 0x3090
movl (%rax), %edi
callq 0x3330
negl %eax
jmp 0x55ed
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5651
leaq 0x1c5a(%rip), %rcx      # 0x729c
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl $0xc, %eax
retq
addl $-0x58, %ecx
cmpl $0x11, %ecx
ja 0x56a5
leaq 0x1cc4(%rip), %rdx      # 0x7324
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_O3/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:
movl %esi, %eax
movl (%rdi), %esi
cmpl $0x14, %esi
jb 0x5730
leal -0x14(%rsi), %r8d
addl $0x3, %eax
andl $-0x4, %eax
cmpl %eax, %r8d
jae 0x5736
movl $0xffffffeb, %eax       # imm = 0xFFFFFFEB
retq
movl %eax, %r8d
addq %r8, %rdi
addq $0x14, %rdi
subl %eax, %esi
addl $-0x14, %esi
jmp 0x3540
// File: /workspace/github_c_makefile_star2_O3/sabotage-linux[P]libnl-tiny/genl.c
// Function: genlmsg_parse
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:
movl (%rdi), %eax
cmpl $0x14, %eax
jb 0x577e
leal -0x14(%rax), %r9d
addl $0x3, %esi
andl $-0x4, %esi
cmpl %esi, %r9d
jae 0x5784
movl $0xffffffeb, %eax       # imm = 0xFFFFFFEB
retq
movl %esi, %r9d
addq %rdi, %r9
addq $0x14, %r9
subl %esi, %eax
addl $-0x14, %eax
movq %rdx, %rdi
movl %ecx, %esi
movq %r9, %rdx
movl %eax, %ecx
jmp 0x3310
// File: /workspace/github_c_makefile_star2_O3/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 0x5842
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 0x5847
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58a8
movq %rax, %r14
movl %ebp, 0x28(%rax)
leaq 0x18(%rax), %rdi
movl $0xf, %edx
movq %r15, %rsi
callq 0x30a0
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 0x58ad
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x593b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x58(%rdi), %rax
cmpq %r14, %rax
je 0x590a
leaq -0x8(%rax), %rdi
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, 0x8(%r15)
movq %r15, (%rax)
callq 0x3060
movq %r15, %rax
cmpq %r14, %r15
jne 0x58eb
movq 0x68(%rbx), %rax
addq $0x68, %rbx
cmpq %rbx, %rax
je 0x5936
leaq -0x8(%rax), %rdi
movq (%rax), %r14
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
callq 0x3060
movq %r14, %rax
cmpq %rbx, %r14
jne 0x5917
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rsi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x5972
movl -0x8(%r12), %esi
movl -0x4(%r12), %edx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
jns 0x5951
jmp 0x5999
addq $0x68, %rbx
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x5997
movl 0x20(%r15), %esi
leaq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x3360
testl %eax, %eax
jns 0x5979
jmp 0x5999
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sabotage-linux[P]libnl-tiny/genl_family.c
// Function: family_compare
static int family_compare(struct nl_object *_a, struct nl_object *_b,
			  uint32_t attrs, int flags)
{
	struct genl_family *a = (struct genl_family *) _a;
	struct genl_family *b = (struct genl_family *) _b;
	int diff = 0;

#define FAM_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, FAMILY_ATTR_##ATTR, a, b, EXPR)

	diff |= FAM_DIFF(ID,		a->gf_id != b->gf_id);
	diff |= FAM_DIFF(VERSION,	a->gf_version != b->gf_version);
	diff |= FAM_DIFF(HDRSIZE,	a->gf_hdrsize != b->gf_hdrsize);
	diff |= FAM_DIFF(MAXATTR,	a->gf_maxattr != b->gf_maxattr);
	diff |= FAM_DIFF(NAME,		strcmp(a->gf_name, b->gf_name));

#undef FAM_DIFF

	return diff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
movl $0x0, %r14d
testb $0x1, %dl
je 0x59d4
movl 0x30(%rdi), %eax
andl 0x30(%rsi), %eax
testb $0x1, %al
je 0x59ce
movzwl 0x34(%rdi), %eax
cmpw 0x34(%rsi), %ax
je 0x59d4
movl $0x1, %r14d
testb $0x4, %dl
je 0x59f0
movl 0x30(%rdi), %eax
andl 0x30(%rsi), %eax
testb $0x4, %al
je 0x59eb
movl 0x48(%rdi), %eax
cmpl 0x48(%rsi), %eax
je 0x59f0
movl $0x4, %ebp
xorl %r15d, %r15d
movl $0x0, %ebx
testb $0x8, %dl
je 0x5a14
movl 0x30(%rdi), %eax
andl 0x30(%rsi), %eax
testb $0x8, %al
je 0x5a0f
movl 0x4c(%rdi), %eax
cmpl 0x4c(%rsi), %eax
je 0x5a14
movl $0x8, %ebx
testb $0x10, %dl
je 0x5a31
movl 0x30(%rdi), %eax
andl 0x30(%rsi), %eax
testb $0x10, %al
je 0x5a2b
movl 0x50(%rdi), %eax
cmpl 0x50(%rsi), %eax
je 0x5a31
movl $0x10, %r15d
xorl %r12d, %r12d
testb $0x2, %dl
je 0x5a5a
movl 0x30(%rdi), %eax
andl 0x30(%rsi), %eax
testb $0x2, %al
je 0x5a54
addq $0x36, %rdi
addq $0x36, %rsi
callq 0x3280
testl %eax, %eax
je 0x5a5a
movl $0x2, %r12d
orl %r14d, %ebp
orl %r15d, %ebx
orl %ebp, %ebx
orl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x593e(%rip), %rax      # 0xb3c8
cmpq %rax, 0x20(%rdi)
jne 0x5ab1
xorl %eax, %eax
movq %rdi, %rcx
movq (%rcx), %rcx
cmpq %rdi, %rcx
je 0x5aaf
movzwl 0x1c(%rcx), %edx
cmpl %esi, %edx
jne 0x5a95
incl -0x18(%rcx)
addq $-0x18, %rcx
movq %rcx, %rax
popq %rcx
retq
callq 0x396f
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5903(%rip), %rax      # 0xb3c8
cmpq %rax, 0x20(%rdi)
jne 0x5b0b
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rdi, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x5afc
leaq 0x1e(%r12), %rsi
movq %r14, %rdi
callq 0x3280
testl %eax, %eax
jne 0x5ad6
incl -0x18(%r12)
addq $-0x18, %r12
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x39b2