LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/agx100/agx100_cfg_parser.c
// Function: agx100_handler
static int
agx100_handler(void *user, const char *section,
	     const char *name, const char *value)
{
	struct agx100_conf *agx100_conf =
			(struct agx100_conf *) user;
	int ret = 1;

	if (!strcmp(section, MODE) && !strcmp(name, PFMODE)) {
		if (!strcmp(value, ZERO))
			agx100_conf->pf_mode_en = false;
		else if (!strcmp(value, ONE))
			agx100_conf->pf_mode_en = true;
		else
			ret = 0;
	} else if (!strcmp(section, UL) && !strcmp(name, LOAD_BALANCE)) {
		ret = parse_number8(value, &agx100_conf->ul_load_balance);
	} else if (!strcmp(section, DL) && !strcmp(name, LOAD_BALANCE)) {
		ret = parse_number8(value, &agx100_conf->dl_load_balance);
	} else if (!strcmp(section, UL) && !strcmp(name, QUEUE_MAP)) {
		ret = parse_array8(value, agx100_conf->vf_ul_queues_number);
	} else if (!strcmp(section, DL) && !strcmp(name, QUEUE_MAP)) {
		ret = parse_array8(value, agx100_conf->vf_dl_queues_number);
	} else {
		printf("ERROR: Section (%s) or name (%s) is not valid.\n",
		       section, name);
		return 0;
	}
	if (ret != 1)
		printf("Error: Conversion of value (%s) failed.\n", value);

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x4375(%rip), %rsi      # 0x1bbe3
movq %r12, %rdi
callq 0xd1f0
testl %eax, %eax
jne 0x17891
leaq 0x4367(%rip), %rsi      # 0x1bbe8
movq %r15, %rdi
callq 0xd1f0
testl %eax, %eax
je 0x17912
movzbl (%r12), %eax
cmpl $0x44, %eax
je 0x178df
cmpl $0x55, %eax
jne 0x178ef
cmpb $0x4c, 0x1(%r12)
jne 0x178ef
cmpb $0x0, 0x2(%r12)
jne 0x178ef
leaq 0x47cf(%rip), %rsi      # 0x1c086
movq %r15, %rdi
callq 0xd1f0
testl %eax, %eax
je 0x17976
leaq 0x47c5(%rip), %rsi      # 0x1c093
movq %r15, %rdi
callq 0xd1f0
testl %eax, %eax
jne 0x178ef
incq %r14
jmp 0x17957
cmpb $0x4c, 0x1(%r12)
jne 0x178ef
cmpb $0x0, 0x2(%r12)
je 0x1792d
leaq 0x47b5(%rip), %rdi      # 0x1c0ab
xorl %r14d, %r14d
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd150
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl (%rbx), %eax
xorl %ebp, %ebp
cmpl $0x31, %eax
je 0x17964
cmpl $0x30, %eax
jne 0x1799c
cmpb $0x0, 0x1(%rbx)
jne 0x1799c
movb $0x0, (%r14)
jmp 0x1796e
leaq 0x4752(%rip), %rsi      # 0x1c086
movq %r15, %rdi
callq 0xd1f0
testl %eax, %eax
je 0x1797c
leaq 0x474c(%rip), %rsi      # 0x1c093
movq %r15, %rdi
callq 0xd1f0
testl %eax, %eax
jne 0x178ef
addq $0x9, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17a09
jmp 0x1798b
cmpb $0x0, 0x1(%rbx)
jne 0x1799c
movb $0x1, (%r14)
movl $0x1, %r14d
jmp 0x17906
addq $0x11, %r14
jmp 0x17980
addq $0x12, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x179b5
movl %eax, %ebp
movl $0x1, %r14d
cmpl $0x1, %eax
je 0x17906
leaq 0x4738(%rip), %rdi      # 0x1c0db
movq %rbx, %rsi
xorl %eax, %eax
callq 0xd150
movl %ebp, %r14d
jmp 0x17906
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_set_bus_master
static int vfio_set_bus_master(hw_device *hwd)
{
	int i;
	uint8_t config[VFIO_PCI_CONFIG_REGION_SIZE];

	for (i = 0; i < hwd->num_regions; i++) {
		struct vfio_region_info reg = {
				.argsz = sizeof(reg), .index = i
		};

		if (ioctl(hwd->vfio_dev_fd, VFIO_DEVICE_GET_REGION_INFO, &reg))
			continue;

		if (i == VFIO_PCI_CONFIG_REGION_INDEX) {
			uint16_t *vendor;
			uint16_t *cmd;

			if (vfio_read(hwd->vfio_dev_fd, config, sizeof(config), reg.offset))
				return -1;

			vendor = (uint16_t *)(config + PCI_VENDOR_ID);
			cmd = (uint16_t *)(config + PCI_COMMAND);

			if (*vendor == 0xffff) {
				LOG(ERR, "device in bad state");
				return -1;
			}

			*cmd |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
			if (vfio_write(hwd->vfio_dev_fd, cmd,
					sizeof(*cmd), reg.offset + PCI_COMMAND))
				return -1;

			if (vfio_read(hwd->vfio_dev_fd, cmd,
					sizeof(*cmd), reg.offset + PCI_COMMAND))
				return -1;

			LOG(DEBUG, "vendor=%#x cmd=%#x device=%#x rev=%d",
					*vendor, *cmd,
					(uint32_t)*((uint16_t *)(config + PCI_DEVICE_ID)),
					(uint32_t)config[PCI_REVISION_ID]);

			break;
		}
	} /* loop on all regions */

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
cmpl $0x0, 0xcc(%rdi)
jle 0x17ee8
movq %rdi, %rbx
movq %rsp, %r14
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x20, (%rsp)
movl %ebp, 0x8(%rsp)
movl 0xc0(%rbx), %edi
movl $0x3b6c, %esi           # imm = 0x3B6C
movq %r14, %rdx
xorl %eax, %eax
callq 0xd190
cmpl $0x7, %ebp
jne 0x17ede
testl %eax, %eax
je 0x17eec
incl %ebp
cmpl 0xcc(%rbx), %ebp
jl 0x17ea9
xorl %ebx, %ebx
jmp 0x17f0f
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x17abd
testl %eax, %eax
je 0x17f1f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpw $-0x1, 0x20(%rsp)
je 0x17fce
leaq 0x24(%rsp), %r14
orb $0x6, (%r14)
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
movl $0x2, %edx
movq %r14, %rsi
callq 0x17b0e
testl %eax, %eax
jne 0x17f0a
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
movl $0x2, %edx
movq %r14, %rsi
callq 0x17abd
testl %eax, %eax
jne 0x17f0a
callq 0x18c40
leaq 0x1bf50(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movzwl 0x20(%rsp), %r10d
movzwl 0x24(%rsp), %r11d
movzwl 0x22(%rsp), %r14d
movzbl 0x28(%rsp), %r15d
leaq 0x6053(%rip), %rdx      # 0x1dff6
leaq 0x607e(%rip), %r9       # 0x1e028
xorl %ebx, %ebx
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x199b4
addq $0x20, %rsp
jmp 0x17f0f
callq 0x18c40
leaq 0x1bef6(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x5ff7(%rip), %rdx      # 0x1dfdb
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
jmp 0x17f0a
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_intr_handler
static void vfio_intr_handler(int event_fd, void *dev)
{
	hw_device *hwd = (hw_device *)dev;
	int len;
	uint64_t buf;

	LOG(DEBUG, "VFIO interrupt handler:");

	do {
		len = read(event_fd, &buf, sizeof(buf));
		LOG(DEBUG, "event val: %lu, len:%d", buf, len);

		if (len < 0) {
			LOG(ERR, "vfio event irq recv() failed");
			return;
		}
	} while (len != sizeof(buf));

	if (hwd->ops.dev_isr)
		hwd->ops.dev_isr(hwd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
callq 0x18c40
leaq 0x1beb8(%rip), %rbx     # 0x33ed0
movq 0x18(%rbx), %r8
leaq 0x60f8(%rip), %rdx      # 0x1e11b
leaq 0x6116(%rip), %r14      # 0x1e140
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x199b4
leaq 0x10(%rsp), %r15
leaq 0x6108(%rip), %r12      # 0x1e152
movl $0x8, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0xd1d0
movq %rax, %r13
callq 0x18c40
movq 0x18(%rbx), %r8
movl $0x3, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
pushq %r13
pushq 0x18(%rsp)
callq 0x199b4
addq $0x10, %rsp
testl %r13d, %r13d
js 0x180b6
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
cmpl $0x8, %r13d
jne 0x1804a
movq 0x8(%rsp), %rdi
movq 0x60(%rdi), %rax
addq $0x18, %rsp
testq %rax, %rax
je 0x180e1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
callq 0x18c40
movq (%rbx), %r8
leaq 0x60b1(%rip), %rdx      # 0x1e176
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x199b4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_uuid_parse
int vfio_uuid_parse(char *uuid_str, unsigned char *uuid)
{
	int i, inx;
	int high_n = 1;
	unsigned char tmp;

	if (strlen(uuid_str) != VFIO_VF_TOKEN_STR_LEN) {
		LOG(ERR, "uuid string len is wrong: %d", (int)strlen(uuid_str));
		return -1;
	}
	for (i = 0, inx = 0;
			((i < VFIO_VF_TOKEN_STR_LEN) && (inx < VFIO_VF_TOKEN_LEN));
			i++) {
		if (uuid_str[i] == '-') {
			if ((i ==  8) || (i == 13) || (i == 18) || (i == 23))
				continue;
		}
		if (!isxdigit(uuid_str[i])) {
			LOG(ERR, "Unknown char in uuid string");
			return -1;
		}
		tmp = isdigit(uuid_str[i]) ? uuid_str[i] - '0' :
				tolower(uuid_str[i]) - 'a' + 0xA;

		if (high_n) {
			uuid[inx] = (tmp & 0xF) << 4;
			high_n = 0;
		} else {
			uuid[inx++] |= (tmp & 0xF);
			high_n = 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %rbx
callq 0xd110
cmpq $0x24, %rax
jne 0x183b4
movl $0x1, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movzbl (%rbx,%r15), %ebp
cmpl $0x2d, %ebp
jne 0x18337
cmpl $0x17, %r15d
ja 0x18337
movl $0x842100, %eax         # imm = 0x842100
btl %r15d, %eax
jb 0x1839d
callq 0xd440
movq (%rax), %rax
movsbq %bpl, %r14
movzwl (%rax,%r14,2), %eax
btl $0xc, %eax
jae 0x183eb
btl $0xb, %eax
jb 0x18369
callq 0xd430
movq (%rax), %rax
movl (%rax,%r14,4), %ebp
addl $-0x57, %ebp
jmp 0x1836c
addl $-0x30, %ebp
testl %r13d, %r13d
jne 0x1838b
movslq %r12d, %rax
incl %r12d
andb $0xf, %bpl
movq (%rsp), %rcx
orb %bpl, (%rcx,%rax)
movl $0x1, %r13d
jmp 0x1839d
shlb $0x4, %bpl
movslq %r12d, %rax
movq (%rsp), %rcx
movb %bpl, (%rcx,%rax)
xorl %r13d, %r13d
xorl %eax, %eax
cmpq $0x22, %r15
ja 0x18414
incq %r15
cmpl $0x10, %r12d
jl 0x1831c
jmp 0x18414
callq 0x18c40
movq %rax, %r14
leaq 0x1bb0d(%rip), %rax     # 0x33ed0
movq (%rax), %r15
movq %rbx, %rdi
callq 0xd110
leaq 0x581d(%rip), %rdx      # 0x1dbf2
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x199b4
jmp 0x1840f
callq 0x18c40
leaq 0x1bad9(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x5815(%rip), %rdx      # 0x1dc16
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/daemon.c
// Function: reset_mode_exec
static int
reset_mode_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct reset_mode_req *reset_mode = (struct reset_mode_req *)CMD_REQ(ci);
	const char *reset_mode_str[2] = {"cluster_reset", "pf_flr"};


	if ((reset_mode->mode != RESET_MODE_CLUSTER_LEVEL) &&
			(reset_mode->mode != RESET_MODE_FLR)) {
		LOG(ERR, "Unknown reset_mode request:%d", reset_mode->mode);
		return -1;
	}
	LOG(INFO, "reset_mode set to : %s", reset_mode_str[reset_mode->mode]);

	update_reset_mode(cmd_req->priv, reset_mode->mode);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rsi), %ebp
callq 0x19969
movl 0x10(%rbx), %r9d
leaq 0x1b22b(%rip), %rcx     # 0x33ed0
cmpl $0x2, %ebp
jae 0x18ce4
movq 0x10(%rcx), %r8
leaq 0x5d2f(%rip), %rcx      # 0x1e9e4
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5af7(%rip), %rdx      # 0x1e7ba
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x1a0a9
jmp 0x18d01
movq (%rcx), %r8
leaq 0x5aa7(%rip), %rdx      # 0x1e795
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/daemon.c
// Function: auto_reset_exec
static int
auto_reset_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct auto_reset_req *auto_reset = (struct auto_reset_req *)CMD_REQ(ci);
	const char *auto_reset_str[2] = {"off", "on"};

	if ((auto_reset->mode != AUTO_RESET_OFF) &&
			(auto_reset->mode != AUTO_RESET_ON)) {
		LOG(ERR, "Unknown auto_reset mode: %d", auto_reset->mode);
		return -1;
	}
	LOG(INFO, "Auto reset set to : %s", auto_reset_str[auto_reset->mode]);

	auto_reset_mode(cmd_req->priv, auto_reset->mode);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rsi), %ebp
callq 0x19969
movl 0x10(%rbx), %r9d
leaq 0x1b1ad(%rip), %rcx     # 0x33ed0
cmpl $0x2, %ebp
jae 0x18d62
movq 0x10(%rcx), %r8
leaq 0x5cb9(%rip), %rcx      # 0x1e9ec
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5ac1(%rip), %rdx      # 0x1e802
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x1a123
jmp 0x18d7f
movq (%rcx), %r8
leaq 0x5a73(%rip), %rdx      # 0x1e7df
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/daemon.c
// Function: exit_app_exec
static int
exit_app_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	hw_device *accel_dev = (hw_device *)cmd_req->priv;

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

	LOG(INFO, "exit_app command received");
	sig_fun(0);
	return 0;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rdi
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x18e07
callq *%rax
testl %eax, %eax
je 0x18e07
callq 0x19969
leaq 0x1b0e8(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x5a65(%rip), %rdx      # 0x1e857
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x18e38
callq 0x19969
leaq 0x1b0bd(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x5a5a(%rip), %rdx      # 0x1e878
xorl %ebx, %ebx
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
xorl %edi, %edi
callq 0x198ed
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/daemon.c
// Function: mem_read_exec
static int
mem_read_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct mm_read_req *mm_read = (struct mm_read_req *)CMD_REQ(ci);

	LOG(INFO, "mm_read command received");
	LOG(DEBUG, "mm_read: reg_op_flag	= 0x%x\n", mm_read->reg_op_flag);
	LOG(DEBUG, "mm_read: reg_rw_address	= 0x%x\n", mm_read->reg_rw_address);
	LOG(DEBUG, "mm_read: write_payload	= 0x%x\n", mm_read->write_payload);

	acc_mem_read(cmd_req->priv, mm_read->reg_op_flag,
			mm_read->reg_rw_address, mm_read->write_payload);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x19969
leaq 0x1b003(%rip), %r15     # 0x33ed0
movq 0x10(%r15), %r8
leaq 0x5a1d(%rip), %rdx      # 0x1e8f5
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
callq 0x19969
movq 0x18(%r15), %r8
movl 0x10(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5a16(%rip), %rdx      # 0x1e915
leaq 0x5a39(%rip), %r14      # 0x1e93f
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x199b4
callq 0x19969
movq 0x18(%r15), %r8
movl 0x14(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5a1d(%rip), %rdx      # 0x1e94d
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x199b4
callq 0x19969
movq 0x18(%r15), %r8
movl 0x18(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5a20(%rip), %rdx      # 0x1e97a
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x199b4
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %ecx
callq 0x1a4e5
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/daemon.c
// Function: event_add_fd
int event_add_fd(int fd, cbFp_t cbFp,  void *cbData)
{
	int i;

	if (eventFd.pollfd_count >= MAX_EVENTS) {
		LOG(ERR, "failed to add event fd");
		return -1;
	}

	for (i = 0; i < MAX_EVENTS; i++) {
		if (eventFd.fd[i] != -1)
			continue;

		eventFd.fd[i] = fd;
		eventFd.cbFp[i] = cbFp;
		eventFd.cbData[i] = cbData;
		eventFd.pollfd_count++;
		LOG(DEBUG, "location: %d, pollfd_count=%d", i, eventFd.pollfd_count);
		return 0;
	}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0xa, 0x21870(%rip)     # 0x3aa70
jle 0x1921a
callq 0x19969
leaq 0x1acc2(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x5274(%rip), %rdx      # 0x1e48c
jmp 0x1924c
leaq 0x21717(%rip), %rax     # 0x3a938
xorl %r14d, %r14d
cmpl $-0x1, (%rax)
je 0x19261
incq %r14
addq $0x4, %rax
cmpq $0xb, %r14
jne 0x19224
callq 0x19969
leaq 0x1ac8e(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x5296(%rip), %rdx      # 0x1e4e2
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x192bd
movl %edi, (%rax)
leaq 0x216ce(%rip), %rax     # 0x3a938
movq %rsi, 0x30(%rax,%r14,8)
movq %rdx, 0x88(%rax,%r14,8)
incl 0x217f3(%rip)           # 0x3aa70
callq 0x19969
leaq 0x1ac47(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movl 0x217dc(%rip), %r10d    # 0x3aa70
leaq 0x520f(%rip), %rdx      # 0x1e4aa
leaq 0x5233(%rip), %r9       # 0x1e4d5
xorl %ebx, %ebx
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x199b4
addq $0x10, %rsp
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x21666(%rip), %rax     # 0x3a938
xorl %r14d, %r14d
cmpl %edi, (%rax)
je 0x19311
incq %r14
addq $0x4, %rax
cmpq $0xb, %r14
jne 0x192d5
callq 0x19969
leaq 0x1abde(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x520e(%rip), %rdx      # 0x1e50a
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x19371
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x2161a(%rip), %rax     # 0x3a938
xorl %ebx, %ebx
movq %rbx, 0x30(%rax,%r14,8)
movq %rbx, 0x88(%rax,%r14,8)
decl 0x2173d(%rip)           # 0x3aa70
callq 0x19969
leaq 0x1ab91(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movl 0x21726(%rip), %r10d    # 0x3aa70
leaq 0x5159(%rip), %rdx      # 0x1e4aa
leaq 0x51a5(%rip), %r9       # 0x1e4fd
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x199b4
addq $0x10, %rsp
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x18fcc
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x195ff
movl %eax, %ebp
leaq -0x26b(%rip), %rsi      # 0x1937b
movl %eax, %edi
movq %r14, %rdx
callq 0x191f5
testl %eax, %eax
js 0x195f8
movl %ebp, %ebx
jmp 0x195ff
movl %ebp, %edi
callq 0xd1a0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edi, %ebx
movzwl 0x21176(%rip), %ebp     # 0x3aa70
callq 0x19969
leaq 0x1a5ca(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x4c79(%rip), %rdx      # 0x1e58a
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x199b4
testl %ebp, %ebp
je 0x1995d
movb $0x1, %r14b
movl 0x2113e(%rip), %eax     # 0x3aa70
leaq 0x20fff(%rip), %rbx     # 0x3a938
cltq
movl (%rbx,%rax,4), %edi
callq 0xd1a0
movl 0x21127(%rip), %eax     # 0x3aa70
decl %eax
movl %eax, 0x2111f(%rip)     # 0x3aa70
movzbl %r14b, %ecx
leal 0x1(%rcx), %r14d
cmpl %ecx, %ebp
ja 0x19939
movb $0x1, 0x21134(%rip)     # 0x3aa98
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_log
int
bb_acc_log(int level, int log_type, const char *format, ...)
{
	va_list ap;
	int ret;

	va_start(ap, format);
	ret = bb_acc_vlog(level, log_type, format, ap);
	va_end(ap);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x19a0d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
cmpl $0x0, 0x2108c(%rip)     # 0x3aac0
je 0x19a91
testl %esi, %esi
leaq 0x21069(%rip), %rcx     # 0x3aaa8
leaq 0x2106a(%rip), %rax     # 0x3aab0
cmoveq %rcx, %rax
cmpl %edi, 0x21050(%rip)     # 0x3aaa0
jl 0x19a99
movq (%rax), %r14
testq %r14, %r14
je 0x19aac
movq %r14, %rdi
callq 0xd210
cmpq 0x2104f(%rip), %rax     # 0x3aab8
jbe 0x19a77
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd2b0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd370
movl %eax, %ebx
movq %r14, %rdi
callq 0xd280
jmp 0x19ab1
cmpl %edi, 0x21009(%rip)     # 0x3aaa0
jge 0x19a9d
xorl %ebx, %ebx
jmp 0x19ab1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2a0
movl %eax, %ebx
jmp 0x19ab1
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
xorl %r13d, %r13d
testl %r8d, %r8d
je 0x19b90
cmpq $0x0, 0x20fc6(%rip)     # 0x3aaa8
jne 0x19bb5
movl %r8d, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x4f0c(%rip), %rsi      # 0x1ea04
callq 0xd320
testq %rax, %rax
jne 0x19b1a
leaq 0x4efe(%rip), %rsi      # 0x1ea07
movq %r15, %rdi
callq 0xd320
testq %rax, %rax
je 0x19bc7
movq %rax, %r13
leaq 0x4ee0(%rip), %rsi      # 0x1ea04
movq %r12, %rdi
callq 0xd320
testq %rax, %rax
jne 0x19b49
leaq 0x4ecf(%rip), %rsi      # 0x1ea07
movq %r12, %rdi
callq 0xd320
testq %rax, %rax
je 0x19bd5
movq %rax, %r15
movq %r13, 0x20f55(%rip)     # 0x3aaa8
movq %rax, 0x20f56(%rip)     # 0x3aab0
movq %r14, 0x20f57(%rip)     # 0x3aab8
movl %ebx, 0x20f39(%rip)     # 0x3aaa0
movl %ebp, 0x20f53(%rip)     # 0x3aac0
movq %r13, %rdi
xorl %r13d, %r13d
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2b0
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2b0
jmp 0x19bb5
movq %r13, 0x20f11(%rip)     # 0x3aaa8
movq %r13, 0x20f12(%rip)     # 0x3aab0
movq %r14, 0x20f13(%rip)     # 0x3aab8
movl %ebx, 0x20ef5(%rip)     # 0x3aaa0
movl $0x0, 0x20f0b(%rip)     # 0x3aac0
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e3c(%rip), %rdi      # 0x1ea0a
callq 0xd330
jmp 0x19be9
leaq 0x4e2e(%rip), %rdi      # 0x1ea0a
callq 0xd330
movq %r13, %rdi
callq 0xd0f0
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x19bb5
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0xd180
cmpq $0x0, 0x20e6f(%rip)     # 0x3aaa8
je 0x19c6b
leaq 0x4ddd(%rip), %rsi      # 0x1ea1f
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xd3d0
movq %r15, %rdi
callq 0xd140
testl %eax, %eax
jne 0x19c94
testl %ebx, %ebx
je 0x19c78
movq 0x20e47(%rip), %rdi     # 0x3aab0
jmp 0x19c7f
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x20e29(%rip), %rdi     # 0x3aaa8
xorl %esi, %esi
xorl %edx, %edx
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd2b0
leaq 0x4d95(%rip), %rdi      # 0x1ea30
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd330
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x19d6a
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x19d22
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19d22
callq 0x1a858
leaq 0x1a1ba(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x4b37(%rip), %rdx      # 0x1e857
jmp 0x19d80
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x19d58
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19d58
callq 0x1a858
leaq 0x1a190(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x146b1(%rip), %rdx     # 0x2e3fb
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %rbx, %rdi
callq 0x19d95
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x19d93
callq 0x1a858
leaq 0x1a15a(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x14665(%rip), %rdx     # 0x2e3e5
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0xb0(%rdi), %rsi
xorl %ecx, %ecx
callq *0x38(%rdi)
testl %eax, %eax
je 0x19de1
leaq 0x14a16(%rip), %rbx     # 0x2e7cd
callq 0x1a858
leaq 0x1a10d(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x19e65
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x19dfc
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19dfc
leaq 0x170a(%rip), %rbx      # 0x1b504
jmp 0x19db7
callq 0x1a858
leaq 0x1a0c8(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
movq (%rbx), %r9
leaq 0x20(%rbx), %rcx
movq %rcx, (%rsp)
leaq 0x149cd(%rip), %rdx     # 0x2e7eb
xorl %r14d, %r14d
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0x3, %eax
cmpq $0x5, 0xf0(%rbx,%r14,8)
jne 0x19e52
xorl %eax, %eax
cmpl $0x1, 0x4f4(%rbx)
sete %al
xorq $0x7, %rax
movq %rax, 0xf0(%rbx,%r14,8)
incq %r14
cmpq $0x40, %r14
jne 0x19e32
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1a858
leaq 0x1a050(%rip), %r14     # 0x33ed0
movq 0x18(%r14), %r8
leaq 0x1458b(%rip), %rdx     # 0x2e416
leaq 0x145ac(%rip), %r9      # 0x2e43e
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
testq %rbx, %rbx
je 0x19f4c
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x19ee4
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19ee4
callq 0x1a858
movq (%r14), %r8
leaq 0x4988(%rip), %rdx      # 0x1e857
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x19f4c
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x19ef4
movq %rbx, %rdi
callq *%rax
jmp 0x19f11
callq 0x1a858
movq (%r14), %r8
leaq 0x1455d(%rip), %rdx     # 0x2e460
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %rbx, %rdi
callq 0x19d95
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x19f4c
callq 0x1a858
movq 0x18(%r14), %r8
leaq 0x15f2(%rip), %rdx      # 0x1b524
leaq 0x14505(%rip), %r9      # 0x2e43e
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1a858
leaq 0x19f6a(%rip), %r14     # 0x33ed0
movq 0x18(%r14), %r8
leaq 0x144a5(%rip), %rdx     # 0x2e416
leaq 0x1450e(%rip), %r9      # 0x2e486
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
testq %rbx, %rbx
je 0x1a064
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x19fcd
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19fcd
callq 0x1a858
movq (%r14), %r8
leaq 0x48a2(%rip), %rdx      # 0x1e857
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1a064
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x19fdd
movq %rbx, %rdi
callq *%rax
jmp 0x19ffa
callq 0x1a858
movq (%r14), %r8
leaq 0x14474(%rip), %rdx     # 0x2e460
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x1a029
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a029
callq 0x1a858
movq (%r14), %r8
leaq 0x143e0(%rip), %rdx     # 0x2e3fb
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %rbx, %rdi
callq 0x19d95
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1a064
callq 0x1a858
movq 0x18(%r14), %r8
leaq 0x14da(%rip), %rdx      # 0x1b524
leaq 0x14435(%rip), %r9      # 0x2e486
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1a858
leaq 0x19e0e(%rip), %r12     # 0x33ed0
movq 0x18(%r12), %r8
leaq 0x143de(%rip), %rdx     # 0x2e4ac
leaq 0x143f7(%rip), %r15     # 0x2e4cc
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x199b4
movl %ebx, 0x4f4(%r14)
callq 0x1a858
movq 0x18(%r12), %r8
leaq 0x1423(%rip), %rdx      # 0x1b524
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x199b4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1a858
leaq 0x19d94(%rip), %r12     # 0x33ed0
movq 0x18(%r12), %r8
leaq 0x14396(%rip), %rdx     # 0x2e4de
leaq 0x143b5(%rip), %r15     # 0x2e504
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x199b4
movl %ebx, 0x4f0(%r14)
callq 0x1a858
movq 0x18(%r12), %r8
leaq 0x13a9(%rip), %rdx      # 0x1b524
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x199b4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x90, %rsp
leaq 0x20(%rdi), %rcx
leaq 0xfcb(%rip), %rsi       # 0x1b17b
leaq 0xfd8(%rip), %rdx       # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3d0
callq 0x1a858
leaq 0x19cfe(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x14333(%rip), %rdx     # 0x2e514
leaq 0x14347(%rip), %r9      # 0x2e52f
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19c11
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x90, %rsp
leaq 0x20(%rdi), %rcx
leaq 0xf79(%rip), %rsi       # 0x1b198
leaq 0xf69(%rip), %rdx       # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3d0
callq 0x1a858
leaq 0x19c8f(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x142ee(%rip), %rdx     # 0x2e53e
leaq 0x14305(%rip), %r9      # 0x2e55c
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x19c11
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
jle 0x1a301
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
shlq $0x4, %r12
leaq 0x142cf(%rip), %r15     # 0x2e570
xorl %ebp, %ebp
movq 0xb0(%r14), %rax
movl 0x8(%rbx,%rbp), %ecx
movl (%rax,%rcx), %r13d
callq 0x1a858
leaq 0x19c12(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
movq (%rbx,%rbp), %r9
movl 0x8(%rbx,%rbp), %r10d
movl $0x2, %edi
movl $0x1, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
pushq %r13
pushq %r10
callq 0x199b4
addq $0x10, %rsp
addq $0x10, %rbp
cmpq %rbp, %r12
jne 0x1a2a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/bb_acc_common.c
// Function: vrb1_reg_dump
int
vrb1_reg_dump(hw_device *accel_dev,
		struct vrb1_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:
testl %edx, %edx
jle 0x1a387
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
shlq $0x4, %r12
leaq 0x14249(%rip), %r15     # 0x2e570
xorl %ebp, %ebp
movq 0xb0(%r14), %rax
movl 0x8(%rbx,%rbp), %ecx
movl (%rax,%rcx), %r13d
callq 0x1a858
leaq 0x19b8c(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
movq (%rbx,%rbp), %r9
movl 0x8(%rbx,%rbp), %r10d
movl $0x2, %edi
movl $0x1, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
pushq %r13
pushq %r10
callq 0x199b4
addq $0x10, %rsp
addq $0x10, %rbp
cmpq %rbp, %r12
jne 0x1a329
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
cmpl %esi, 0x1c(%rdi)
jne 0x1a450
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1a20c
cmpl $0x57c2, %ebp           # imm = 0x57C2
je 0x1a474
cmpl $0x57c0, %ebp           # imm = 0x57C0
je 0x1a45e
cmpl $0xd5c, %ebp            # imm = 0xD5C
jne 0x1a48a
leaq 0x19aaf(%rip), %rsi     # 0x33ef0
movq %rbx, %rdi
movl $0x308, %edx            # imm = 0x308
callq 0x1a27e
jmp 0x1a4b1
leaq 0x143c0(%rip), %rdi     # 0x2e817
callq 0xd0c0
jmp 0x1a4dc
leaq 0x1cb0b(%rip), %rsi     # 0x36f70
movq %rbx, %rdi
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x1a304
jmp 0x1a4b1
leaq 0x1ea05(%rip), %rsi     # 0x38e80
movq %rbx, %rdi
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x1a38a
jmp 0x1a4b1
callq 0x1a858
leaq 0x19a3a(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x140ec(%rip), %rdx     # 0x2e58c
xorl %edi, %edi
movl $0x1, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
callq 0x1a858
leaq 0x19a13(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x140e6(%rip), %rdx     # 0x2e5ae
movl $0x2, %edi
movl $0x1, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0xd180
testl %r15d, %r15d
je 0x1a791
movl %r15d, %r12d
leaq 0x1406c(%rip), %r15     # 0x2e7c9
xorl %eax, %eax
movq 0xb0(%r14), %rcx
movl %ebp, %edx
movl (%rcx,%rdx), %ecx
movslq %eax, %r13
leaq (%rsp,%r13), %rdi
movl $0x400, %eax            # imm = 0x400
subl %r13d, %eax
movslq %eax, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd170
addl %r13d, %eax
addl %ebx, %ebp
decq %r12
jne 0x1a75f
callq 0x1a858
leaq 0x19733(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x14017(%rip), %rdx     # 0x2e7bf
movq %rsp, %r9
movl $0x2, %edi
movl $0x1, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x1a20c
movl 0x1c(%rbx), %eax
cmpl $0x57c2, %eax           # imm = 0x57C2
je 0x1a824
cmpl $0x57c0, %eax           # imm = 0x57C0
je 0x1a81a
cmpl $0xd5c, %eax            # imm = 0xD5C
jne 0x1a82c
movq %rbx, %rdi
callq 0xf644
jmp 0x1a82c
movq %rbx, %rdi
callq 0x12802
jmp 0x1a82c
movq %rbx, %rdi
callq 0x1602b
callq 0x1a858
leaq 0x19698(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x13d6b(%rip), %rdx     # 0x2e5ae
movl $0x2, %edi
movl $0x1, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x199b4
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/minalpherv11/avx2/encrypt.cpp
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
  unsigned char       *m,
  unsigned long long  *mlen,
  unsigned char       *nsec,
  const unsigned char *c,
  unsigned long long  clen,
  const unsigned char *ad,
  unsigned long long  adlen,
  const unsigned char *npub,
  const unsigned char *k
  )
{
  unsigned long long cr;
  int d, ret=0;
  MIE_ALIGN(128) unsigned char tag[32] = { 0 };

  cr = clen + adlen;
  if( (cr<clen) && (cr<adlen) ) return -1;

  clen -= TAGBYTES;
  if( clen % BLOCK_SIZE ) return -1;
  if( clen < BLOCK_SIZE ) return -1;

  //minalpher tag verification
  if (minalpher_mode_tag_generation(k, npub, ad, adlen, c, clen, tag) < 0){
    return -1;
  }
  for( d=0; d<TAGBYTES; d++ ){
    if( tag[d] != c[d+clen] ) ret |= 1;
  }
  if( ret != 0 )  return -1;

  //minalpher decryption
  if (minalpher_mode_decryption(k, npub, c, clen, m, mlen) < 0){
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x80, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %r13
movq 0x10(%rbp), %rcx
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %ymm0, 0x80(%rsp)
movq %r8, %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
addq %rcx, %rax
jb 0xaeb6
movq %r8, %r14
addq $-0x10, %r14
testb $0x1f, %r14b
setne %al
cmpq $0x20, %r14
setb %dl
orb %al, %dl
jne 0xaeb6
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rsi
leaq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq %r9, %rdx
movq %r13, %r8
movq %r14, %r9
vzeroupper
callq 0x20c0
testl %eax, %eax
js 0xaeb6
vmovq 0x80(%rsp), %xmm0
vmovq (%r13,%r14), %xmm1
vpcmpneqb %xmm1, %xmm0, %k0
vmovq 0x88(%rsp), %xmm0
vmovq 0x8(%r13,%r14), %xmm1
vpcmpneqb %xmm1, %xmm0, %k1
kortestb %k1, %k0
jne 0xaeb6
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x2130
movl %eax, %ebx
sarl $0x1f, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
nop
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_create_default
obvector * obvector_create_default(uint32_t initial_capacity){

  static const char classname[] = "obvector";

  obvector *new_instance = malloc(sizeof(obvector));
  assert(new_instance != NULL);

  /* initialize reference counting base data */
  ob_init_base((obj *)new_instance, &obvector_destroy, &obvector_hash, &obvector_compare,
           &obvector_display, classname);

  /* a vector with zero capacity cannot be created, create one with a capacity
   * of one */
  if(initial_capacity == 0){
    initial_capacity = 1;
  }

  new_instance->array = malloc(initial_capacity*sizeof(obj *));
  assert(new_instance->array != NULL);

  new_instance->capacity = initial_capacity;
  new_instance->length = 0;

  return new_instance;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x18, %edi
callq 0x10c0
testq %rax, %rax
je 0x1e6a
movq %rax, %r14
leaq 0x882(%rip), %rsi       # 0x2695
leaq 0x8e4(%rip), %rdx       # 0x26fe
leaq 0x9cc(%rip), %rcx       # 0x27ed
leaq 0xad2(%rip), %r8        # 0x28fa
leaq 0x1ee6(%rip), %r9       # 0x3d15
movq %rax, %rdi
callq 0x295c
cmpl $0x1, %ebx
adcl $0x0, %ebx
leaq (,%rbx,8), %rdi
callq 0x10c0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x1e89
movl %ebx, 0x14(%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1803(%rip), %rdi      # 0x3674
leaq 0x19c0(%rip), %rsi      # 0x3838
leaq 0x1c47(%rip), %rcx      # 0x3ac6
movl $0xb5, %edx
callq 0x1060
leaq 0x1c62(%rip), %rdi      # 0x3af2
leaq 0x19a1(%rip), %rsi      # 0x3838
leaq 0x1c28(%rip), %rcx      # 0x3ac6
movl $0xc2, %edx
callq 0x1060