LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_append
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
{
	void *tmp;

	tmp = nlmsg_reserve(n, len, pad);
	if (tmp == NULL)
		return -NLE_NOMEM;

	memcpy(tmp, data, len);
	NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x3090
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x537b
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x5395
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3330
jmp 0x538e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x10, (%rax)
jae 0x540f
jmp 0x53cc
movq 0x8c25(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x4c64(%rip), %rsi      # 0xa041
leaq 0x4c95(%rip), %rdx      # 0xa079
movl $0x1dd, %ecx            # imm = 0x1DD
movb $0x0, %al
callq 0x32e0
leaq 0x4c61(%rip), %rdi      # 0xa058
leaq 0x4c7b(%rip), %rsi      # 0xa079
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x4c75(%rip), %rcx      # 0xa07f
callq 0x3210
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x6(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x544d
cmpl $0x0, -0x20(%rbp)
jle 0x5475
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x3090
cmpq $0x0, %rax
jne 0x5475
movq $0x0, -0x8(%rbp)
jmp 0x547d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x8955(%rip), %rax      # 0xde00
movq %rax, -0x38(%rbp)
movq 0x8952(%rip), %rax      # 0xde08
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5580
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5590
movl -0x4c(%rbp), %edi
movzwl 0x4(%rax), %esi
callq 0x35d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x54ff
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x552f
leaq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5590
movq -0x58(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rcx
callq 0x3530
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x4, -0x18(%rbp)
movb %al, -0x19(%rbp)
jb 0x5644
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x4, %rcx
movb %al, -0x19(%rbp)
jb 0x5644
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpq -0x18(%rbp), %rax
setbe %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3240
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3360
cmpl $0x0, %eax
je 0x5765
movq -0x30(%rbp), %rdi
callq 0x57a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x5711
movq 0x88fa(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x49e7(%rip), %rsi      # 0xa0ef
movb $0x0, %al
callq 0x32e0
jmp 0x574f
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x574d
cmpq $0x0, -0x28(%rbp)
je 0x573d
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x57c0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x573b
jmp 0x578d
jmp 0x573d
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x574f
movq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3540
movq %rax, -0x30(%rbp)
jmp 0x56d0
cmpl $0x0, -0x34(%rbp)
jle 0x5786
movq 0x8886(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movl -0x34(%rbp), %edx
leaq 0x498c(%rip), %rsi      # 0xa10b
movb $0x0, %al
callq 0x32e0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57a0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x57f4
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x5800
movl $0x0, -0x4(%rbp)
jmp 0x595a
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x8, %eax
jle 0x5864
jmp 0x5821
movq 0x87d0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x480f(%rip), %rsi      # 0xa041
leaq 0x4908(%rip), %rdx      # 0xa141
movl $0x1c6, %ecx            # imm = 0x1C6
movb $0x0, %al
callq 0x32e0
leaq 0x480c(%rip), %rdi      # 0xa058
leaq 0x48ee(%rip), %rsi      # 0xa141
movl $0x1c6, %edx            # imm = 0x1C6
leaq 0x48e9(%rip), %rcx      # 0xa148
callq 0x3210
movq -0x28(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x587c
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x58a1
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x589f
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
leaq 0x8ae8(%rip), %rax      # 0xe380
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
jmp 0x58a1
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x6, %eax
jne 0x58c7
movq -0x10(%rbp), %rdi
callq 0x5c70
cmpl $0x0, %eax
jle 0x58c7
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x595a
movq -0x10(%rbp), %rdi
callq 0x5c70
cmpl -0x2c(%rbp), %eax
jge 0x58de
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x595a
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x5909
movq -0x10(%rbp), %rdi
callq 0x5c70
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jle 0x5909
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x595a
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x5, %eax
jne 0x5953
movq -0x10(%rbp), %rdi
callq 0x5c50
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c70
movl %eax, %ecx
movq -0x40(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5951
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x595a
jmp 0x5953
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3360
cmpl $0x0, %eax
je 0x59d5
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x57c0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x59c0
jmp 0x59dc
jmp 0x59c2
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x3540
movq %rax, -0x20(%rbp)
jmp 0x5994
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3360
cmpl $0x0, %eax
je 0x5a4e
movq -0x20(%rbp), %rdi
callq 0x57a0
cmpl -0x18(%rbp), %eax
jne 0x5a39
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a56
jmp 0x5a3b
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x3540
movq %rax, -0x20(%rbp)
jmp 0x5a10
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
addl $0x4, %eax
subl $0x1, %eax
andl $-0x4, %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %edi
callq 0x5b40
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
addl (%rcx), %eax
movl %eax, %eax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x5abd
movq $0x0, -0x8(%rbp)
jmp 0x5b30
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x5b70
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x18(%rbp), %edi
callq 0x5ba0
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %edi
callq 0x5bb0
movq -0x30(%rbp), %rdi
movslq %eax, %rdx
xorl %esi, %esi
callq 0x3240
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, (%rax)
jmp 0x5b28
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3650
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5c19
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x5c3b
movq -0x28(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x3330
jmp 0x5c34
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x32c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5cc0
movq $0x0, -0x8(%rbp)
jmp 0x5cef
jmp 0x5cc2
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x5ce7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3550
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5d30
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x5d6f
cmpq $0x0, -0x18(%rbp)
je 0x5d5d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3680
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x5d5d
movq -0x28(%rbp), %rdi
callq 0x3050
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d6f
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x5dae
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5dcb
jmp 0x5db0
jmp 0x5db2
movq -0x18(%rbp), %rdi
callq 0x3220
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5df5
jmp 0x5e09
movq -0x8(%rbp), %rdi
callq 0x3220
jmp 0x5e00
movq -0x8(%rbp), %rdi
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_clear
void nl_cache_clear(struct nl_cache *cache)
{
	struct nl_object *obj, *tmp;

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

	nl_list_for_each_entry_safe(obj, tmp, &cache->c_items, ce_list)
		nl_cache_remove(obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x5e1e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
je 0x5ea1
movq -0x10(%rbp), %rdi
callq 0x3410
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5e5d
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5ed1
jmp 0x5f02
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x6030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x5f02
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x5f3f
movl $0xffffffe9, -0x4(%rbp) # imm = 0xFFFFFFE9
jmp 0x5f91
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x5fa0
cmpl $0x0, %eax
jne 0x5f70
movq -0x18(%rbp), %rdi
callq 0x3400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5f6e
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x5f91
jmp 0x5f81
movq -0x18(%rbp), %rdi
callq 0x5fc0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5fe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache.c
// Function: _cache_add
static int __cache_add(struct nl_cache *cache, struct nl_object *obj)
{
	obj->ce_cache = cache;

	nl_list_add_tail(&obj->ce_list, &cache->c_items);
	cache->c_nitems++;

	NL_DBG(1, "Added %p to cache %p <%s>.\n",
	       obj, cache, nl_cache_name(cache));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
callq 0x63f0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x601c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/include/netlink/object.h
// Function: nl_object_put
static inline void nl_object_put(struct nl_object *obj)
{
	if (!obj)
		return;

	obj->ce_refcnt--;

	if (obj->ce_refcnt <= 0)
		nl_object_free(obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6075
jmp 0x6092
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x6092
movq -0x8(%rbp), %rdi
callq 0x3130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_request_full_dump
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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x60b2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x60ca
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x60e3
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x611a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3440
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x613b
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x6181
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
leaq 0x43(%rip), %rcx        # 0x6190
leaq -0x40(%rbp), %r8
callq 0x3690
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3190
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x6172
jmp 0x616e
jmp 0x6170
jmp 0x6172
movq -0x30(%rbp), %rdi
callq 0x3300
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache.c
// Function: nl_cache_pickup
int nl_cache_pickup(struct nl_sock *sk, struct nl_cache *cache)
{
	struct nl_parser_param p = {
		.pp_cb = pickup_cb,
		.pp_arg = cache,
	};

	return __cache_pickup(sk, cache, &p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x29(%rip), %rax        # 0x6220
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3150
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x6320
cmpl $0x0, %eax
jne 0x6289
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x630a
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jl 0x62fd
movq -0x10(%rbp), %rax
addq $0x48, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x62f0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movl %eax, -0x30(%rbp)
cmpl $-0xa, -0x30(%rbp)
je 0x62ee
jmp 0x6304
jmp 0x62f0
jmp 0x62f2
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6290
movl $0xffffffea, -0x30(%rbp) # imm = 0xFFFFFFEA
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x167(%rip), %rax      # 0x6220
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rcx
callq 0x3530
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache_mngt.c
// Function: nl_cache_ops_lookup
struct nl_cache_ops *nl_cache_ops_lookup(const char *name)
{
	struct nl_cache_ops *ops;

	for (ops = cache_ops; ops; ops = ops->co_next)
		if (!strcmp(ops->co_name, name))
			return ops;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x82a5(%rip), %rax      # 0xe728
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x64bd
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x64ad
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x64c5
jmp 0x64af
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6487
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq 0x8247(%rip), %rax      # 0xe728
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x655a
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x64fa
jmp 0x654c
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x48, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jl 0x654a
movq -0x20(%rbp), %rax
addq $0x48, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x653d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6562
jmp 0x653f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6501
jmp 0x654c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x64e5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6591
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x659a
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x65d8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3510
cmpq $0x0, %rax
je 0x65b5
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x65d8
movq 0x816c(%rip), %rcx      # 0xe728
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x8159(%rip)      # 0xe728
jmp 0x65d1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/cache_mngt.c
// Function: nl_cache_mngt_unregister
int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
{
	struct nl_cache_ops *t, **tp;

	for (tp = &cache_ops; (t=*tp) != NULL; tp = &t->co_next)
		if (t == ops)
			break;

	if (!t)
		return -NLE_NOCACHE;

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

	*tp = t->co_next;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x8129(%rip), %rax      # 0xe728
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6630
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x6620
jmp 0x6630
jmp 0x6622
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
jmp 0x6603
cmpq $0x0, -0x18(%rbp)
jne 0x6640
movl $0xffffffe8, -0x4(%rbp) # imm = 0xFFFFFFE8
jmp 0x665a
jmp 0x6642
jmp 0x6644
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x38, 0x8(%rax)
jae 0x66bc
jmp 0x6679
movq 0x7978(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x39b7(%rip), %rsi      # 0xa041
leaq 0x3af3(%rip), %rdx      # 0xa184
movl $0x2f, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x39b4(%rip), %rdi      # 0xa058
leaq 0x3ad9(%rip), %rsi      # 0xa184
movl $0x2f, %edx
leaq 0x3ad6(%rip), %rcx      # 0xa18d
callq 0x3210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x32c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x66e3
movq $0x0, -0x8(%rbp)
jmp 0x673e
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6732
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x6734
jmp 0x6736
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68e0
movq %rax, -0x20(%rbp)
movl $0x34, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6791
movq $0x0, -0x8(%rbp)
jmp 0x68c8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x67ee
jmp 0x67ab
movq 0x7846(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x3885(%rip), %rsi      # 0xa041
leaq 0x39c1(%rip), %rdx      # 0xa184
movl $0x58, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x3882(%rip), %rdi      # 0xa058
leaq 0x39a7(%rip), %rsi      # 0xa184
movl $0x58, %edx
leaq 0x39de(%rip), %rcx      # 0xa1c7
callq 0x3210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
cmpl $0x0, -0x28(%rbp)
je 0x6831
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x24(%rbp), %rax
addq %rax, %rsi
movslq -0x28(%rbp), %rdx
callq 0x3330
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6868
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x6866
movq -0x18(%rbp), %rdi
callq 0x3130
movq $0x0, -0x8(%rbp)
jmp 0x68c8
jmp 0x68c0
cmpl $0x0, -0x28(%rbp)
je 0x68be
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x68be
jmp 0x687b
movq 0x7776(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x37b5(%rip), %rsi      # 0xa041
leaq 0x38f1(%rip), %rdx      # 0xa184
movl $0x66, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x37b2(%rip), %rdi      # 0xa058
leaq 0x38d7(%rip), %rsi      # 0xa184
movl $0x66, %edx
leaq 0x390e(%rip), %rcx      # 0xa1c7
callq 0x3210
jmp 0x68c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x68e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x6978
jmp 0x6974
jmp 0x6976
jmp 0x6978
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x698c
movq -0x8(%rbp), %rdi
callq 0x3410
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x69a5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x3070
jmp 0x69b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: nl_socket_alloc
struct nl_sock *nl_socket_alloc(void)
{
	struct nl_cb *cb;
	
	cb = nl_cb_alloc(NL_CB_DEFAULT);
	if (!cb)
		return NULL;

	return __alloc_socket(cb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
callq 0x3100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x69e4
movq $0x0, -0x8(%rbp)
jmp 0x69f1
movq -0x10(%rbp), %rdi
callq 0x6a00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x32c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6a30
movq $0x0, -0x8(%rbp)
jmp 0x6aa6
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movw $0x10, (%rax)
movq -0x18(%rbp), %rax
movw $0x10, 0xc(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x3380
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
callq 0x6ce0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x6a9e
movq -0x18(%rbp), %rdi
callq 0x35a0
movq $0x0, -0x8(%rbp)
jmp 0x6aa6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6b65
jmp 0x6bac
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x6b7b
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x3270
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x6b96
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x6bc0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3300
movq -0x8(%rbp), %rdi
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: release_local_port
static void release_local_port(uint32_t port)
{
	int nr;

	if (port == UINT_MAX)
		return;
	
	nr = port >> 22;
	used_ports_map[nr / 32] &= ~(1 << nr % 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x6bcf
jmp 0x6c17
movl -0x4(%rbp), %eax
shrl $0x16, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl -0xc(%rbp), %edx
movslq %eax, %rcx
leaq 0x7b26(%rip), %rax      # 0xe730
andl (%rax,%rcx,4), %edx
leaq 0x7b1c(%rip), %rax      # 0xe730
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6c9c
callq 0x6ce0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0x28(%rax)
jmp 0x6cc4
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x6cb7
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x6bc0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x28(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/socket.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3170
andl $0x3fffff, %eax         # imm = 0x3FFFFF
movl %eax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x6dab
movslq -0x8(%rbp), %rcx
leaq 0x7a1f(%rip), %rax      # 0xe730
cmpl $-0x1, (%rax,%rcx,4)
jne 0x6d1c
jmp 0x6d9d
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x6d9b
movslq -0x8(%rbp), %rcx
leaq 0x79fc(%rip), %rax      # 0xe730
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
shrl %cl, %eax
movl %eax, %eax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x6d4a
jmp 0x6d90
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movslq -0x8(%rbp), %rcx
leaq 0x79ce(%rip), %rax      # 0xe730
movl (%rax,%rcx,4), %eax
orq %rdx, %rax
movl %eax, %edx
leaq 0x79bf(%rip), %rax      # 0xe730
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll $0x16, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6db2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d23
jmp 0x6d9d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6cfc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x6df8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x6e31
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x6f25
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x0, -0x14(%rbp)
je 0x6f1a
cmpl $0x0, -0x14(%rbp)
jge 0x6e71
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x6f25
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x10e, %esi            # imm = 0x10E
movl $0x1, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x3140
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x6eb1
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6f25
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x6eec
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x6f09
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x6e55
leaq -0x30(%rbp), %rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)