LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: event_del_fd
int event_del_fd(int fd)
{
	int i;

	for (i = 0; i < MAX_EVENTS; i++) {
		if (eventFd.fd[i] == fd) {
			eventFd.fd[i] = -1;
			eventFd.cbFp[i] = NULL;
			eventFd.cbData[i] = NULL;
			eventFd.pollfd_count--;
			LOG(DEBUG, "location: %d, pollfd_count=%d", i, eventFd.pollfd_count);
			return 0;
		}
	}

	LOG(ERR, "Event del failed");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xb, -0xc(%rbp)
jge 0x20de9
movslq -0xc(%rbp), %rcx
leaq 0x21601(%rip), %rax     # 0x42338
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x20dd9
movslq -0xc(%rbp), %rcx
leaq 0x215ea(%rip), %rax     # 0x42338
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movslq -0xc(%rbp), %rcx
leaq 0x215d8(%rip), %rax     # 0x42338
movq $0x0, 0x30(%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
leaq 0x215c4(%rip), %rax     # 0x42338
movq $0x0, 0x88(%rax,%rcx,8)
movl 0x216ea(%rip), %eax     # 0x42470
addl $-0x1, %eax
movl %eax, 0x216e1(%rip)     # 0x42470
callq 0x21530
movq %rax, %rcx
leaq 0x1ab32(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl -0xc(%rbp), %r10d
movl 0x216c4(%rip), %eax     # 0x42470
movl $0x3, %edi
xorl %esi, %esi
leaq 0x56ac(%rip), %rdx      # 0x26466
leaq 0x56f8(%rip), %r9       # 0x264b9
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
jmp 0x20e14
jmp 0x20ddb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20d22
callq 0x21530
movq %rax, %rcx
leaq 0x1aad8(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x56c2(%rip), %rdx      # 0x264c6
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: cli_channel_event_processor
void cli_channel_event_processor(int fd, void *data)
{
	struct cmdReq *req = (struct cmdReq *)&cmdReq_g;
	struct cmdDef *cmd;

	if (data == NULL) {
		LOG(ERR, "event data is null");
		return;
	}
	if (!unix_channel_srv_rx(fd, req)) {
		if (get_cmd_by_id(req->id, &cmd) == -1)
			return;
		if (cmd->exec != NULL) {
			req->priv = data;
			cmd->exec(cmd, (void *)req);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x21642(%rip), %rax     # 0x42478
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x20e67
callq 0x21530
movq %rax, %rcx
leaq 0x1aa80(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x5682(%rip), %rdx      # 0x264de
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
jmp 0x20eba
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x20ec0
cmpl $0x0, %eax
jne 0x20eba
movq -0x18(%rbp), %rax
movswl (%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x21030
cmpl $-0x1, %eax
jne 0x20e8f
jmp 0x20eba
movq -0x20(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x20eb8
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x20eba
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: unix_channel_srv_rx
static int
unix_channel_srv_rx(int fd, struct cmdReq *req)
{
	int rc;
	int client_fd;

	LOG(DEBUG, "data received on cli channel");

	client_fd = accept(fd, NULL, NULL);
	if (client_fd < 0) {
		LOG(ERR, "cli channel: accept() failed");
		return -1;
	}
	LOG(DEBUG, "client connected fd: %d", client_fd);

	rc = recv(client_fd, req, sizeof(struct cmdReq), 0);
	if (rc < 0) {
		LOG(ERR, "cmd request recv() failed");
		close(client_fd);
		return -1;
	}

	LOG(DEBUG, "Req id: %04x, len: %d", req->id, req->len);

	close(client_fd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1a9f2(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x567e(%rip), %rdx      # 0x2656e
leaq 0x56a1(%rip), %r9       # 0x26598
movb $0x0, %al
callq 0x216e0
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd390
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x20f46
callq 0x21530
movq %rax, %rcx
leaq 0x1a9ab(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x567b(%rip), %rdx      # 0x265ac
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21022
callq 0x21530
movq %rax, %rcx
leaq 0x1a97b(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl -0x18(%rbp), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x5666(%rip), %rdx      # 0x265d0
leaq 0x5627(%rip), %r9       # 0x26598
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0xd040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x20fcc
callq 0x21530
movq %rax, %rcx
leaq 0x1a92a(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x5643(%rip), %rdx      # 0x265f5
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl -0x18(%rbp), %edi
callq 0xd190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21022
callq 0x21530
movq %rax, %rcx
leaq 0x1a8f5(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x10(%rbp), %rax
movswl (%rax), %r10d
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x5619(%rip), %rdx      # 0x26616
leaq 0x5594(%rip), %r9       # 0x26598
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
movl -0x18(%rbp), %edi
callq 0xd190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: get_cmd_by_id
static int
get_cmd_by_id(int cmd_id, struct cmdDef **cd)
{
	int i;

	for (i = 0; i < NO_OF_CMDS; i++) {
		if (cmd_id == cmd_defs[i].id)
			break;
	}

	if (cmd_defs[i].id == -1) {
		LOG(ERR, "command id: %d is not supported", cmd_id);
		return -1;
	}

	*cd = &cmd_defs[i];

	LOG(DEBUG, "found command: %s, id: %d", cmd_defs[i].cmd, cmd_defs[i].id);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x21074
movl -0x8(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x1a3f6(%rip), %rcx     # 0x3b450
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x21067
jmp 0x21074
jmp 0x21069
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x21046
movslq -0x14(%rbp), %rcx
leaq 0x1a3d1(%rip), %rax     # 0x3b450
shlq $0x7, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jne 0x210bf
callq 0x21530
movq %rax, %rcx
leaq 0x1a836(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movl -0x8(%rbp), %r9d
xorl %esi, %esi
leaq 0x558f(%rip), %rdx      # 0x26639
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21140
movslq -0x14(%rbp), %rax
leaq 0x1a386(%rip), %rcx     # 0x3b450
shlq $0x7, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x21530
movq %rax, %rcx
leaq 0x1a7e9(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movslq -0x14(%rbp), %rax
leaq 0x1a35a(%rip), %r10     # 0x3b450
shlq $0x7, %rax
addq %rax, %r10
addq $0x4, %r10
movslq -0x14(%rbp), %rdx
leaq 0x1a344(%rip), %rax     # 0x3b450
shlq $0x7, %rdx
addq %rdx, %rax
movl (%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x553d(%rip), %rdx      # 0x26660
leaq 0x555d(%rip), %r9       # 0x26687
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: cli_channel_init
int cli_channel_init(hw_device *dev)
{
	int fd;

	fd = unix_channel_srv_init(dev);
	if (fd < 0)
		return -1;

	if (event_add_fd(fd, cli_channel_event_processor, dev) < 0) {
		close(fd);
		return -1;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x208e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x21177
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x211a6
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq -0x365(%rip), %rsi      # 0x20e20
callq 0x20bc0
cmpl $0x0, %eax
jge 0x211a0
movl -0x14(%rbp), %edi
callq 0xd190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x211a6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: daemonize
void
daemonize(hw_device *dev)
{
	pid_t pid, sid;

	(void) signal(SIGTERM, sig_fun);
	(void) signal(SIGKILL, sig_fun);
	(void) signal(SIGABRT, sig_fun);
	(void) signal(SIGSEGV, sig_fun);
	(void) signal(SIGBUS, sig_fun);
	(void) signal(SIGILL, sig_fun);

	pid = fork();
	if (pid < 0)
		exit(EXIT_FAILURE);

	/* exit the parent */
	if (pid > 0)
		exit(EXIT_SUCCESS);

	umask(0);

	/* do not let the child to become orphan */
	sid = setsid();
	if (sid < 0)
		exit(EXIT_FAILURE);

	close(STDIN_FILENO);
	close(STDOUT_FILENO);
	close(STDERR_FILENO);

	if (cli_channel_init(dev) < 0) {
		LOG(ERR, "cli channel init failed");
		return;
	}

	LOG(DEBUG, "Event processor started");

	/* blocks on events */
	event_processor(dev);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xf, %edi
leaq 0x138(%rip), %rsi       # 0x21300
callq 0xd1f0
movl $0x9, %edi
leaq 0x127(%rip), %rsi       # 0x21300
callq 0xd1f0
movl $0x6, %edi
leaq 0x116(%rip), %rsi       # 0x21300
callq 0xd1f0
movl $0xb, %edi
leaq 0x105(%rip), %rsi       # 0x21300
callq 0xd1f0
movl $0x7, %edi
leaq 0xf4(%rip), %rsi        # 0x21300
callq 0xd1f0
movl $0x4, %edi
leaq 0xe3(%rip), %rsi        # 0x21300
callq 0xd1f0
callq 0xd420
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2123a
movl $0x1, %edi
callq 0xd3f0
cmpl $0x0, -0xc(%rbp)
jle 0x21247
xorl %edi, %edi
callq 0xd3f0
xorl %edi, %edi
callq 0xd210
callq 0xd1a0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x21266
movl $0x1, %edi
callq 0xd3f0
xorl %edi, %edi
callq 0xd190
movl $0x1, %edi
callq 0xd190
movl $0x2, %edi
callq 0xd190
movq -0x8(%rbp), %rdi
callq 0x21150
cmpl $0x0, %eax
jge 0x212b5
callq 0x21530
movq %rax, %rcx
leaq 0x1a632(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x524e(%rip), %rdx      # 0x264f8
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
jmp 0x212ed
callq 0x21530
movq %rax, %rcx
leaq 0x1a60c(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x5241(%rip), %rdx      # 0x26517
leaq 0x525f(%rip), %r9       # 0x2653c
movb $0x0, %al
callq 0x216e0
movq -0x8(%rbp), %rdi
callq 0x21390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: sig_fun
void sig_fun(int sig)
{
	uint8_t loopCnt = 0;
	uint16_t fdCnt = eventFd.pollfd_count;
	LOG(INFO, "Signal Received with sigNum = %u", sig);
	while (loopCnt < fdCnt) {
		/* Close all the communications */
		close(eventFd.fd[eventFd.pollfd_count]);
		eventFd.pollfd_count--;
		loopCnt++;
	}
	/* set "is_sig_term_rcv = 1"; so that event_processor exits */
	is_sig_term_rcv = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movl 0x2115b(%rip), %eax     # 0x42470
movw %ax, -0x8(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1a5a8(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl -0x4(%rbp), %r9d
movl $0x2, %edi
xorl %esi, %esi
leaq 0x5208(%rip), %rdx      # 0x26546
movb $0x0, %al
callq 0x216e0
movzbl -0x5(%rbp), %eax
movzwl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jge 0x21380
movslq 0x21118(%rip), %rcx     # 0x42470
leaq 0x20fd9(%rip), %rax     # 0x42338
movl (%rax,%rcx,4), %edi
callq 0xd190
movl 0x21103(%rip), %eax     # 0x42470
addl $-0x1, %eax
movl %eax, 0x210fa(%rip)     # 0x42470
movb -0x5(%rbp), %al
addb $0x1, %al
movb %al, -0x5(%rbp)
jmp 0x21345
movl $0x1, 0x2110e(%rip)     # 0x42498
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: event_processor
static void
event_processor(hw_device *dev)
{
	char unix_channel_file[UNIX_CHANNEL_FILE_LEN];
	char sysCmd[1024];
	int r;

	while (!is_sig_term_rcv) {

		event_set_pfds();

		LOG(DEBUG, "Waiting on poll...");

		/* Waits on list of events */
		r = poll(eventFd.pfds, MAX_EVENTS, -1);

		LOG(DEBUG, "poll() unblocked, check events (return %d)", r);

		/* process all events that are set */
		event_process_fds();
	}
	if (is_sig_term_rcv == 1) {
		LOG(INFO, "Exit event processor\n");
		/* Remove the socket file */
		memset(sysCmd, 0, sizeof(sysCmd));
		sprintf(unix_channel_file, "%s.%s.sock", UNIX_CHANNEL_PATH, dev->pci_address);
		sprintf(sysCmd, "rm -fr %s", unix_channel_file);
		r = system(sysCmd);
		LOG(DEBUG, "system cmd returns = %d\n", r);
		/* Close the log file */
		bb_acc_logExit();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x210f2(%rip)     # 0x42498
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x213b4
jmp 0x2144d
callq 0x215c0
callq 0x21530
movq %rax, %rcx
leaq 0x1a508(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x52bb(%rip), %rdx      # 0x26695
leaq 0x52d4(%rip), %r9       # 0x266b5
movb $0x0, %al
callq 0x216e0
leaq 0x20f49(%rip), %rdi     # 0x42338
addq $0xe0, %rdi
movl $0xb, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xd2e0
movl %eax, -0x454(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1a4b6(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl -0x454(%rbp), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x5293(%rip), %rdx      # 0x266c5
leaq 0x527c(%rip), %r9       # 0x266b5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
callq 0x21620
jmp 0x2139f
cmpl $0x1, 0x21044(%rip)     # 0x42498
jne 0x2151e
callq 0x21530
movq %rax, %rcx
leaq 0x1a467(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
xorl %esi, %esi
leaq 0x5282(%rip), %rdx      # 0x266fd
movb $0x0, %al
callq 0x216e0
leaq -0x450(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0xd170
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
leaq 0x4e7c(%rip), %rsi      # 0x26324
leaq 0x4e80(%rip), %rdx      # 0x2632f
movb $0x0, %al
callq 0xd3e0
leaq -0x450(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq 0x5252(%rip), %rsi      # 0x2671a
movb $0x0, %al
callq 0xd3e0
leaq -0x450(%rbp), %rdi
callq 0xd120
movl %eax, -0x454(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1a3e0(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl -0x454(%rbp), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x521c(%rip), %rdx      # 0x26724
leaq 0x51a6(%rip), %r9       # 0x266b5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
callq 0x219f0
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: event_set_pfds
static void event_set_pfds(void)
{
	int i;

	for (i = 0; i < MAX_EVENTS; i++) {
		eventFd.pfds[i].fd = eventFd.fd[i];
		eventFd.pfds[i].events = POLLIN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0xb, -0x4(%rbp)
jge 0x21611
movslq -0x4(%rbp), %rcx
leaq 0x20d5c(%rip), %rax     # 0x42338
movl (%rax,%rcx,4), %edx
movslq -0x4(%rbp), %rcx
leaq 0x20d4e(%rip), %rax     # 0x42338
movl %edx, 0xe0(%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x20d3c(%rip), %rax     # 0x42338
movw $0x1, 0xe4(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x215cb
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: event_process_fds
static void event_process_fds(void)
{
	int i;

	for (i = 0; i < MAX_EVENTS; i++) {
		if ((eventFd.pfds[i].fd != -1) && (eventFd.pfds[i].revents & POLLIN)) {
			eventFd.pfds[i].revents = 0;
			if (eventFd.cbFp[i])
				eventFd.cbFp[i](eventFd.pfds[i].fd, eventFd.cbData[i]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0xb, -0x4(%rbp)
jge 0x216da
movslq -0x4(%rbp), %rcx
leaq 0x20cf4(%rip), %rax     # 0x42338
cmpl $-0x1, 0xe0(%rax,%rcx,8)
je 0x216ca
movslq -0x4(%rbp), %rcx
leaq 0x20cdf(%rip), %rax     # 0x42338
movswl 0xe6(%rax,%rcx,8), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x216ca
movslq -0x4(%rbp), %rcx
leaq 0x20cc4(%rip), %rax     # 0x42338
movw $0x0, 0xe6(%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x20caf(%rip), %rax     # 0x42338
cmpq $0x0, 0x30(%rax,%rcx,8)
je 0x216c8
movslq -0x4(%rbp), %rcx
leaq 0x20c9c(%rip), %rax     # 0x42338
movq 0x30(%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rdx
leaq 0x20c8c(%rip), %rcx     # 0x42338
movl 0xe0(%rcx,%rdx,8), %edi
movslq -0x4(%rbp), %rdx
leaq 0x20c7a(%rip), %rcx     # 0x42338
movq 0x88(%rcx,%rdx,8), %rsi
callq *%rax
jmp 0x216ca
jmp 0x216cc
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2162f
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_vlog
static int
bb_acc_vlog(int level, int log_type, const char *format, va_list ap)
{
	int ret;
	if (!logCtl.vfiopciMode) {
		if (level > logCtl.level)
			return 0;
		ret = vprintf(format, ap);
	} else {
		FILE *fp = logCtl.main_fp;
		if (log_type != 0)
			fp = logCtl.secondary_fp;

		if (level > logCtl.level)
			return 0;

		if (fp == NULL)
			return -1;

		if (ftell(fp) > logCtl.maxSize)
			fseek(fp, 0, SEEK_SET);

		ret = vfprintf(fp, format, ap);
		fflush(fp);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, 0x20d23(%rip)     # 0x424c0
jne 0x217c8
movl -0x8(%rbp), %eax
cmpl 0x20cf8(%rip), %eax     # 0x424a0
jle 0x217b6
movl $0x0, -0x4(%rbp)
jmp 0x2184c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd2b0
movl %eax, -0x24(%rbp)
jmp 0x21846
movq 0x20cd9(%rip), %rax     # 0x424a8
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x217e4
movq 0x20cd0(%rip), %rax     # 0x424b0
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x20cb3(%rip), %eax     # 0x424a0
jle 0x217f8
movl $0x0, -0x4(%rbp)
jmp 0x2184c
cmpq $0x0, -0x30(%rbp)
jne 0x21808
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2184c
movq -0x30(%rbp), %rdi
callq 0xd200
cmpq 0x20ca0(%rip), %rax     # 0x424b8
jbe 0x21829
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd2c0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd380
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0xd290
movl -0x24(%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/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_logInit
int
bb_acc_logInit(char *main_file_name, char *resp_file_name, uint64_t size, int level,
		int vfiopciMode)
{
	FILE *fp = NULL, *fp_2 = NULL;

	if (!vfiopciMode) {
		/* igb_uio mode. */
		logCtl.main_fp = fp;
		logCtl.secondary_fp = fp;
		logCtl.maxSize = size; /* having no use. */
		logCtl.level = level;
		logCtl.vfiopciMode = vfiopciMode;
	} else {
		if (logCtl.main_fp != NULL)
			return 0;

		fp = fopen(main_file_name, "r+");
		if (fp == NULL) {
			fp = fopen(main_file_name, "w+");
			if (fp == NULL) {
				perror("Log file open failed");
				return -1;
			}
		}
		fp_2 = fopen(resp_file_name, "r+");
		if (fp_2 == NULL) {
			fp_2 = fopen(resp_file_name, "w+");
			if (fp_2 == NULL) {
				perror("Log file open failed");
				fclose(fp);
				return -1;
			}
		}

		logCtl.main_fp = fp;
		logCtl.secondary_fp = fp_2;
		logCtl.maxSize = size;
		logCtl.level = level;
		logCtl.vfiopciMode = vfiopciMode;
		fseek(fp, 0, SEEK_END);
		fseek(fp_2, 0, SEEK_END);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x218c9
movq -0x30(%rbp), %rax
movq %rax, 0x20c0c(%rip)     # 0x424a8
movq -0x30(%rbp), %rax
movq %rax, 0x20c09(%rip)     # 0x424b0
movq -0x20(%rbp), %rax
movq %rax, 0x20c06(%rip)     # 0x424b8
movl -0x24(%rbp), %eax
movl %eax, 0x20be5(%rip)     # 0x424a0
movl -0x28(%rbp), %eax
movl %eax, 0x20bfc(%rip)     # 0x424c0
jmp 0x219dc
cmpq $0x0, 0x20bd7(%rip)     # 0x424a8
je 0x218df
movl $0x0, -0x4(%rbp)
jmp 0x219e3
movq -0x10(%rbp), %rdi
leaq 0x50c3(%rip), %rsi      # 0x269ad
callq 0xd330
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2192f
movq -0x10(%rbp), %rdi
leaq 0x50ab(%rip), %rsi      # 0x269b0
callq 0xd330
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2192d
leaq 0x5097(%rip), %rdi      # 0x269b3
callq 0xd340
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x219e3
jmp 0x2192f
movq -0x18(%rbp), %rdi
leaq 0x5073(%rip), %rsi      # 0x269ad
callq 0xd330
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x21985
movq -0x18(%rbp), %rdi
leaq 0x505b(%rip), %rsi      # 0x269b0
callq 0xd330
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x21983
leaq 0x5047(%rip), %rdi      # 0x269b3
callq 0xd340
movq -0x30(%rbp), %rdi
callq 0xd0d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x219e3
jmp 0x21985
movq -0x30(%rbp), %rax
movq %rax, 0x20b18(%rip)     # 0x424a8
movq -0x38(%rbp), %rax
movq %rax, 0x20b15(%rip)     # 0x424b0
movq -0x20(%rbp), %rax
movq %rax, 0x20b12(%rip)     # 0x424b8
movl -0x24(%rbp), %eax
movl %eax, 0x20af1(%rip)     # 0x424a0
movl -0x28(%rbp), %eax
movl %eax, 0x20b08(%rip)     # 0x424c0
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xd2c0
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xd2c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_logExit
void
bb_acc_logExit()
{
	if (logCtl.main_fp == NULL)
		return;

	fclose(logCtl.main_fp);
	fclose(logCtl.secondary_fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x20aac(%rip)     # 0x424a8
jne 0x21a00
jmp 0x21a18
movq 0x20aa1(%rip), %rdi     # 0x424a8
callq 0xd0d0
movq 0x20a9d(%rip), %rdi     # 0x424b0
callq 0xd0d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_reset_logFile
void
bb_acc_reset_logFile(char *file_name, int log_type)
{
	char sysCmd[1024];
	memset(sysCmd, 0, sizeof(sysCmd));
	if (logCtl.main_fp == NULL)
		return;
	sprintf(sysCmd, "truncate -s 0 %s", file_name);
	if (system(sysCmd)) {
		perror("Failed to clear the log file");
		return;
	}
	if (log_type == 0)
		fseek(logCtl.main_fp, 0, SEEK_SET);
	else
		fseek(logCtl.secondary_fp, 0, SEEK_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0xd170
cmpq $0x0, 0x20a5b(%rip)     # 0x424a8
jne 0x21a51
jmp 0x21ab5
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x4f65(%rip), %rsi      # 0x269c8
movb $0x0, %al
callq 0xd3e0
leaq -0x410(%rbp), %rdi
callq 0xd120
cmpl $0x0, %eax
je 0x21a89
leaq 0x4f57(%rip), %rdi      # 0x269d9
callq 0xd340
jmp 0x21ab5
cmpl $0x0, -0xc(%rbp)
jne 0x21aa3
movq 0x20a12(%rip), %rdi     # 0x424a8
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd2c0
jmp 0x21ab5
movq 0x20a06(%rip), %rdi     # 0x424b0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd2c0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_device_status_str
const char *
bb_acc_device_status_str(unsigned int status)
{
	static const char * const dev_sta_string[] = {
		"RTE_BBDEV_DEV_NOSTATUS",
		"RTE_BBDEV_DEV_NOT_SUPPORTED",
		"RTE_BBDEV_DEV_RESET",
		"RTE_BBDEV_DEV_CONFIGURED",
		"RTE_BBDEV_DEV_ACTIVE",
		"RTE_BBDEV_DEV_FATAL_ERR",
		"RTE_BBDEV_DEV_RESTART_REQ",
		"RTE_BBDEV_DEV_RECONFIG_REQ",
		"RTE_BBDEV_DEV_CORRECT_ERR",
	};

	if (status < BBDEV_DEV_STATUS_COUNT)
		return dev_sta_string[status];

	LOG(ERR, "Invalid device status");

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jae 0x21ae7
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x182c3(%rip), %rax     # 0x39da0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x21b13
callq 0x22e70
movq %rax, %rcx
leaq 0x19dda(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x1486f(%rip), %rdx     # 0x36371
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_dev_reset_and_reconfig
int
bb_acc_dev_reset_and_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	if (dev == NULL) {
		LOG(ERR, "Device not set");
		return -1;
	}

	/* disable interrupts */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	/* reset */
	if ((accel_dev->ops.flr) &&
			(accel_dev->ops.flr(accel_dev))) {
		LOG(ERR, "Device reset failed");
	}

	/* re-init and configure the device */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21b6b
callq 0x22e70
movq %rax, %rcx
leaq 0x19d86(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14838(%rip), %rdx     # 0x3638e
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21c16
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x21bb6
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21bb6
callq 0x22e70
movq %rax, %rcx
leaq 0x19d38(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x4c6f(%rip), %rdx      # 0x26813
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21c16
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x21bf8
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21bf8
callq 0x22e70
movq %rax, %rcx
leaq 0x19ced(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x147b5(%rip), %rdx     # 0x363a4
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rdi
callq 0x21c20
cmpl $0x0, %eax
je 0x21c0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21c16
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_reconfigure_device
static int
bb_acc_reconfigure_device(hw_device *accel_dev)
{

	/* Call device specific configuration function */
	if (accel_dev->ops.conf(accel_dev, accel_dev->bar0Addr, accel_dev->config_file,
			BB_ACC_RECFG)) {
		LOG(ERR, "Reconfiguration failed");
		return -1;
	}

	/* enable intr if supported, applicable only in case of vfio */
	if ((accel_dev->ops.enable_intr) &&
			(accel_dev->ops.enable_intr(accel_dev))) {
		LOG(ERR, "Enable interrupts failed");
		return -1;
	}

	LOG(INFO, "%s PF [%s] Reconfiguration complete!",
			accel_dev->device_name, accel_dev->pci_address);

	bb_acc_set_all_device_status(accel_dev, RTE_BBDEV_DEV_CONFIGURED);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0xb0(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdx
xorl %ecx, %ecx
callq *%rax
cmpl $0x0, %eax
je 0x21c84
callq 0x22e70
movq %rax, %rcx
leaq 0x19c6d(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14b25(%rip), %rdx     # 0x36794
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21d1f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x21ccf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21ccf
callq 0x22e70
movq %rax, %rcx
leaq 0x19c1f(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x19e5(%rip), %rdx      # 0x236a2
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21d1f
callq 0x22e70
movq %rax, %rcx
leaq 0x19bf2(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %r9
movq -0x10(%rbp), %rax
addq $0x20, %rax
movl $0x2, %edi
xorl %esi, %esi
leaq 0x14ab3(%rip), %rdx     # 0x367b2
movq %rax, (%rsp)
movb $0x0, %al
callq 0x216e0
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x21ff0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_cluster_reset_and_reconfig
int
bb_acc_cluster_reset_and_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Cluster reset and reconfig");

	if (accel_dev == NULL)
		return 0;

	/* disable interrupts */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	if (accel_dev->ops.cluster_reset)
		accel_dev->ops.cluster_reset(accel_dev);
	else
		LOG(ERR, "Cluster reset is not supported");

	/* re-init and configure the device */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x22e70
movq %rax, %rcx
leaq 0x19b7d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1465a(%rip), %rdx     # 0x363bf
leaq 0x1467b(%rip), %r9      # 0x363e7
movb $0x0, %al
callq 0x216e0
cmpq $0x0, -0x18(%rbp)
jne 0x21d86
movl $0x0, -0x4(%rbp)
jmp 0x21e60
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x21dd4
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21dd4
callq 0x22e70
movq %rax, %rcx
leaq 0x19b1d(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x4a54(%rip), %rdx      # 0x26813
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e60
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x21def
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x21e13
callq 0x22e70
movq %rax, %rcx
leaq 0x19ad2(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x145ff(%rip), %rdx     # 0x36409
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rdi
callq 0x21c20
cmpl $0x0, %eax
je 0x21e2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e60
callq 0x22e70
movq %rax, %rcx
leaq 0x19a97(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1877(%rip), %rdx      # 0x236c2
leaq 0x14595(%rip), %r9      # 0x363e7
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_cluster_reset_and_flr_reconfig
int
bb_acc_cluster_reset_and_flr_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Cluster reset and reconfig");

	if (accel_dev == NULL)
		return 0;

	/* Disable interrupts. */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	/* Cluster reset first. */
	if (accel_dev->ops.cluster_reset)
		accel_dev->ops.cluster_reset(accel_dev);
	else
		LOG(ERR, "Cluster reset is not supported");

	/* PF FLR. */
	if ((accel_dev->ops.flr) &&
			(accel_dev->ops.flr(accel_dev))) {
		LOG(ERR, "Device reset failed");
	}

	/* Re-init and configure the device. */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x22e70
movq %rax, %rcx
leaq 0x19a3d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1451a(%rip), %rdx     # 0x363bf
leaq 0x14583(%rip), %r9      # 0x3642f
movb $0x0, %al
callq 0x216e0
cmpq $0x0, -0x18(%rbp)
jne 0x21ec6
movl $0x0, -0x4(%rbp)
jmp 0x21fe2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x21f14
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21f14
callq 0x22e70
movq %rax, %rcx
leaq 0x199dd(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x4914(%rip), %rdx      # 0x26813
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21fe2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x21f2f
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x21f53
callq 0x22e70
movq %rax, %rcx
leaq 0x19992(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x144bf(%rip), %rdx     # 0x36409
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x21f95
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x21f95
callq 0x22e70
movq %rax, %rcx
leaq 0x19950(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14418(%rip), %rdx     # 0x363a4
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rdi
callq 0x21c20
cmpl $0x0, %eax
je 0x21fac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21fe2
callq 0x22e70
movq %rax, %rcx
leaq 0x19915(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x16f5(%rip), %rdx      # 0x236c2
leaq 0x1445b(%rip), %r9      # 0x3642f
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_set_all_device_status
void
bb_acc_set_all_device_status(void *dev, unsigned int status)
{
	unsigned int i;
	hw_device *accel_dev = (hw_device *)dev;

	for (i = 0; i < BB_ACC_MAX_VFS; i++) {
		if (status == RTE_BBDEV_DEV_CONFIGURED) {
			/* After Hard reset the application needs to restart/reconfigure */
			if (accel_dev->dev_status[i] == RTE_BBDEV_DEV_FATAL_ERR) {
				if (accel_dev->device_reset_using_flr == DEVICE_RESET_USING_FLR)
					accel_dev->dev_status[i] = RTE_BBDEV_DEV_RESTART_REQ;
				else
					accel_dev->dev_status[i] = RTE_BBDEV_DEV_RECONFIG_REQ;
			} else
				accel_dev->dev_status[i] = RTE_BBDEV_DEV_CONFIGURED;
		} else
			accel_dev->dev_status[i] = status;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jae 0x2209c
cmpl $0x3, -0xc(%rbp)
jne 0x22078
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
cmpq $0x5, 0xf0(%rax,%rcx,8)
jne 0x22063
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4f4(%rax)
jne 0x2204e
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x6, 0xf0(%rax,%rcx,8)
jmp 0x22061
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x7, 0xf0(%rax,%rcx,8)
jmp 0x22076
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x3, 0xf0(%rax,%rcx,8)
jmp 0x2208c
movl -0xc(%rbp), %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq %rdx, 0xf0(%rax,%rcx,8)
jmp 0x2208e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2200a
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: update_reset_mode
int
update_reset_mode(void *dev, int mode)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Change reset mode:");

	accel_dev->device_reset_using_flr = mode;

	LOG(DEBUG, "Done");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x22e70
movq %rax, %rcx
leaq 0x1980a(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1437d(%rip), %rdx     # 0x36455
leaq 0x14396(%rip), %r9      # 0x36475
movb $0x0, %al
callq 0x216e0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4f4(%rax)
callq 0x22e70
movq %rax, %rcx
leaq 0x197ce(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x15ae(%rip), %rdx      # 0x236c2
leaq 0x1435a(%rip), %r9      # 0x36475
movb $0x0, %al
callq 0x216e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: auto_reset_mode
int
auto_reset_mode(void *dev, int mode)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Auto reset mode change: ");

	accel_dev->auto_reconfig_on_fatal_error = mode;

	LOG(DEBUG, "Done");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x22e70
movq %rax, %rcx
leaq 0x1977a(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1431f(%rip), %rdx     # 0x36487
leaq 0x1433e(%rip), %r9      # 0x364ad
movb $0x0, %al
callq 0x216e0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4f0(%rax)
callq 0x22e70
movq %rax, %rcx
leaq 0x1973e(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x151e(%rip), %rdx      # 0x236c2
leaq 0x14302(%rip), %r9      # 0x364ad
movb $0x0, %al
callq 0x216e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: clear_log_file
void
clear_log_file(void *dev)
{
	char log_file[BB_ACC_LOG_FILE_LEN];
	hw_device *accel_dev = (hw_device *)dev;
	sprintf(log_file, "%s/pf_bb_cfg_%s.log", BB_ACC_DEFAULT_LOG_PATH,
			accel_dev->pci_address);
	LOG(DEBUG, "log_file = %s", log_file);
	bb_acc_reset_logFile(log_file, BB_ACC_LOG_MAIN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0x20, %rcx
leaq 0x104d(%rip), %rsi      # 0x23240
leaq 0x105a(%rip), %rdx      # 0x23254
movb $0x0, %al
callq 0xd3e0
callq 0x22e70
movq %rax, %rcx
leaq 0x196c0(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
leaq -0x90(%rbp), %rax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x14294(%rip), %rdx     # 0x364bd
leaq 0x142a8(%rip), %r9      # 0x364d8
movq %rax, (%rsp)
movb $0x0, %al
callq 0x216e0
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0x21a20
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: clear_log_resp_file
void
clear_log_resp_file(void *dev)
{
	char log_file[BB_ACC_LOG_FILE_LEN];
	hw_device *accel_dev = (hw_device *)dev;
	sprintf(log_file, "%s/pf_bb_cfg_%s_response.log", BB_ACC_DEFAULT_LOG_PATH,
			accel_dev->pci_address);
	LOG(DEBUG, "logRespFile = %s", log_file);
	bb_acc_reset_logFile(log_file, BB_ACC_LOG_RESP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0x20, %rcx
leaq 0xfca(%rip), %rsi       # 0x2325d
leaq 0xfba(%rip), %rdx       # 0x23254
movb $0x0, %al
callq 0xd3e0
callq 0x22e70
movq %rax, %rcx
leaq 0x19620(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
leaq -0x90(%rbp), %rax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x1421e(%rip), %rdx     # 0x364e7
leaq 0x14235(%rip), %r9      # 0x36505
movq %rax, (%rsp)
movb $0x0, %al
callq 0x216e0
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
callq 0x21a20
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: acc100_reg_dump
int
acc100_reg_dump(hw_device *accel_dev,
		struct acc100_reg_dump_info *rd_db,
		int num_regs)
{
	int i = 0;
	int payload = 0;
	for (i = 0; i < num_regs; i++) {
		payload = reg_read(
				accel_dev->bar0Addr,
				rd_db[i].reg_offset);
		LOG_RESP(INFO, "%s\t\t, 0x%08x, 0x%08x", rd_db[i].reg_name,
				rd_db[i].reg_offset, payload);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x223c2
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x223d0
movl %eax, -0x1c(%rbp)
callq 0x22e70
movq %rax, %rcx
leaq 0x19568(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %r9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl 0x8(%rax), %r10d
movl -0x1c(%rbp), %eax
movl $0x2, %edi
movl $0x1, %esi
leaq 0x14174(%rip), %rdx     # 0x36519
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x22328
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: acc_reg_dump
int acc_reg_dump(void *dev, int devType)
{
	hw_device *device = (hw_device *)dev;
	int num;

	if (device->device_id != devType) {
		printf("ERR: Wrong device configured\n");
		return 0;
	}
	clear_log_resp_file(dev);

	if (devType == ACC100_DEVICE_ID) {
		num = sizeof(acc100_rd_db) / sizeof(struct acc100_reg_dump_info);
		acc100_reg_dump(device, acc100_rd_db, num);
	} else if (devType == VRB1_DEVICE_ID) {
		num = sizeof(vrb1_rd_db) / sizeof(struct vrb1_reg_dump_info);
		vrb1_reg_dump(device, vrb1_rd_db, num);
	} else if (devType == VRB2_DEVICE_ID) {
		num = sizeof(vrb2_rd_db) / sizeof(struct vrb2_reg_dump_info);
		vrb2_reg_dump(device, vrb2_rd_db, num);
	} else
		LOG_RESP(ERR, "Wrong Device for ref_dump!");

	LOG_RESP_END();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x225dd
leaq 0x13f6b(%rip), %rdi     # 0x36535
movb $0x0, %al
callq 0xd140
movl $0x0, -0x4(%rbp)
jmp 0x226b2
movq -0x10(%rbp), %rdi
callq 0x22260
cmpl $0xd5c, -0x14(%rbp)     # imm = 0xD5C
jne 0x2260b
movl $0x308, -0x24(%rbp)     # imm = 0x308
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x192ec(%rip), %rsi     # 0x3b8f0
callq 0x22300
jmp 0x22680
cmpl $0x57c0, -0x14(%rbp)    # imm = 0x57C0
jne 0x22630
movl $0x1f1, -0x24(%rbp)     # imm = 0x1F1
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x1c347(%rip), %rsi     # 0x3e970
callq 0x22400
jmp 0x2267e
cmpl $0x57c2, -0x14(%rbp)    # imm = 0x57C2
jne 0x22655
movl $0x1ab, -0x24(%rbp)     # imm = 0x1AB
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x1e232(%rip), %rsi     # 0x40880
callq 0x224d0
jmp 0x2267c
callq 0x22e70
movq %rax, %rcx
leaq 0x1926c(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %edi, %edi
movl $0x1, %esi
leaq 0x13ede(%rip), %rdx     # 0x36553
movb $0x0, %al
callq 0x216e0
jmp 0x2267e
jmp 0x22680
callq 0x22e70
movq %rax, %rcx
leaq 0x19241(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
movl $0x1, %esi
leaq 0x13ed1(%rip), %rdx     # 0x36575
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: print_all_stat32
void
print_all_stat32(hw_device *accel_dev, uint32_t address, int num, int reg_offset)
{
	char buf[512];
	size_t len;
	uint32_t vf_idx, payload;

	memset(buf, 0, 512);
	len = 0;

	for (vf_idx = 0; vf_idx < num; vf_idx++) {
		payload = reg_read(accel_dev->bar0Addr, address + reg_offset * vf_idx);
		len = print_stat32(buf, len, 1024, payload);
	}
	LOG_RESP(INFO, "%s", buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0xd170
movq $0x0, -0x228(%rbp)
movl $0x0, -0x22c(%rbp)
movl -0x22c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x22d3a
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %eax
imull -0x22c(%rbp), %eax
addl %eax, %esi
callq 0x223d0
movl %eax, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rax
movl %eax, %esi
movl -0x230(%rbp), %ecx
movl $0x400, %edx            # imm = 0x400
callq 0x22d80
cltq
movq %rax, -0x228(%rbp)
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x22cd0
callq 0x22e70
movq %rax, %rcx
leaq 0x18b87(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
leaq -0x220(%rbp), %r9
movl $0x2, %edi
movl $0x1, %esi
leaq 0x13a21(%rip), %rdx     # 0x36786
movb $0x0, %al
callq 0x216e0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_common.c
// Function: acc_device_data
void acc_device_data(void *dev)
{
	hw_device *device = (hw_device *)dev;
	clear_log_resp_file(dev);

	if (device->device_id == ACC100_DEVICE_ID)
		acc100_device_data(device);
	else if (device->device_id == VRB1_DEVICE_ID)
		vrb1_device_data(device);
	else if (device->device_id == VRB2_DEVICE_ID)
		vrb2_device_data(device);
	LOG_RESP_END();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22260
movq -0x10(%rbp), %rax
cmpl $0xd5c, 0x1c(%rax)      # imm = 0xD5C
jne 0x22e05
movq -0x10(%rbp), %rdi
callq 0x105b0
jmp 0x22e37
movq -0x10(%rbp), %rax
cmpl $0x57c0, 0x1c(%rax)     # imm = 0x57C0
jne 0x22e1d
movq -0x10(%rbp), %rdi
callq 0x15d00
jmp 0x22e35
movq -0x10(%rbp), %rax
cmpl $0x57c2, 0x1c(%rax)     # imm = 0x57C2
jne 0x22e33
movq -0x10(%rbp), %rdi
callq 0x1b5a0
jmp 0x22e35
jmp 0x22e37
callq 0x22e70
movq %rax, %rcx
leaq 0x18a8a(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
movl $0x1, %esi
leaq 0x1371a(%rip), %rdx     # 0x36575
movb $0x0, %al
callq 0x216e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/avx2/MinalpherMode.cpp
// Function: create_lprime(long long vector[4]&, unsigned char const*)
static inline void create_lprime(__m256i& ymmLp, const unsigned char *_K){
  MIE_ALIGN(128) unsigned char tmp[32] = { 0 };
  memcpy(tmp, _K, 16);
  ymmLp = _mm256_load_si256((const __m256i*)(tmp));
  minalpher_core_single_block(ymmLp);
  ymmLp = _mm256_xor_si256(ymmLp, _mm256_load_si256((const __m256i*)(tmp)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x80, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2030
movq 0x80(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
vmovdqa (%rax), %ymm0
movq 0x88(%rsp), %rax
vmovdqa %ymm0, (%rax)
movq 0x88(%rsp), %rdi
vzeroupper
callq 0x2040
movq 0x88(%rsp), %rax
vmovdqa (%rax), %ymm1
movq %rsp, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm1, 0xc0(%rsp)
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa 0xc0(%rsp), %ymm0
vpxor 0xa0(%rsp), %ymm0, %ymm0
movq 0x88(%rsp), %rax
vmovdqa %ymm0, (%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)