LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/intel[P]pf-bb-config/agx100/agx100_cfg_parser.c
// Function: agx100_parse_conf_file
int
agx100_parse_conf_file(const char *file_name,
		struct agx100_conf *agx100_conf)
{
	int ret;

	set_default_config(agx100_conf);

	ret = cfg_parse(file_name, agx100_handler, agx100_conf);

	if (ret == -1) {
		printf("ERROR: Error loading configuration file %s\n",
			file_name);
		set_default_config(agx100_conf);
		return -ENOENT;
	} else if (ret == -2) {
		printf("ERROR: Memory allocation error\n");
		set_default_config(agx100_conf);
		return -ENOMEM;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x173c3
leaq 0x6b(%rip), %rsi        # 0x173e4
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13780
cmpl $-0x2, %eax
je 0x173a5
xorl %ebp, %ebp
cmpl $-0x1, %eax
jne 0x173bc
leaq 0x4ca4(%rip), %rdi      # 0x1c03b
movq %r14, %rsi
xorl %eax, %eax
callq 0xd160
pushq $-0x2
jmp 0x173b3
leaq 0x4d45(%rip), %rdi      # 0x1c0f1
callq 0xd0c0
pushq $-0xc
popq %rbp
movq %rbx, %rdi
callq 0x173c3
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x47e4(%rip), %rsi      # 0x1bbe3
movq %r12, %rdi
callq 0xd200
testl %eax, %eax
jne 0x1741e
leaq 0x47d6(%rip), %rsi      # 0x1bbe8
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x1749d
movzbl (%r12), %eax
cmpl $0x44, %eax
je 0x1746c
cmpl $0x55, %eax
jne 0x1747c
cmpb $0x4c, 0x1(%r12)
jne 0x1747c
cmpb $0x0, 0x2(%r12)
jne 0x1747c
leaq 0x4c2d(%rip), %rsi      # 0x1c071
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x174fb
leaq 0x4c23(%rip), %rsi      # 0x1c07e
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
jne 0x1747c
incq %r14
jmp 0x174e2
cmpb $0x4c, 0x1(%r12)
jne 0x1747c
cmpb $0x0, 0x2(%r12)
je 0x174b8
leaq 0x4c13(%rip), %rdi      # 0x1c096
xorl %ebp, %ebp
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd160
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl (%rbx), %eax
xorl %ebp, %ebp
cmpl $0x31, %eax
je 0x174ef
cmpl $0x30, %eax
jne 0x1751f
cmpb $0x0, 0x1(%rbx)
jne 0x1751f
movb $0x0, (%r14)
jmp 0x17517
leaq 0x4bb2(%rip), %rsi      # 0x1c071
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17501
leaq 0x4bac(%rip), %rsi      # 0x1c07e
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
jne 0x1747c
addq $0x9, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17582
jmp 0x17510
cmpb $0x0, 0x1(%rbx)
jne 0x1751f
movb $0x1, (%r14)
jmp 0x17517
addq $0x11, %r14
jmp 0x17505
addq $0x12, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17535
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x1751f
pushq $0x1
popq %rbp
jmp 0x17492
leaq 0x4ba0(%rip), %rdi      # 0x1c0c6
movq %rbx, %rsi
xorl %eax, %eax
callq 0xd160
jmp 0x17492
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rsp, %r14
xorl %r15d, %r15d
cmpl 0xcc(%rbx), %r15d
jge 0x17a60
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x20, (%rsp)
movl %r15d, 0x8(%rsp)
movl 0xc0(%rbx), %edi
movl $0x3b6c, %esi           # imm = 0x3B6C
movq %r14, %rdx
xorl %eax, %eax
callq 0xd1a0
cmpl $0x7, %r15d
jne 0x17a3a
testl %eax, %eax
je 0x17a3f
incl %r15d
jmp 0x179fa
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x17629
testl %eax, %eax
je 0x17a70
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpw $-0x1, 0x20(%rsp)
je 0x17b17
leaq 0x24(%rsp), %r14
orb $0x6, (%r14)
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x17678
testl %eax, %eax
jne 0x17a5d
movl 0xc0(%rbx), %edi
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x17629
testl %eax, %eax
jne 0x17a5d
callq 0x18754
leaq 0x1d403(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
movzwl 0x20(%rsp), %r10d
movzwl 0x24(%rsp), %r11d
movzwl 0x22(%rsp), %ebx
movzbl 0x28(%rsp), %r14d
leaq 0x64b7(%rip), %rdx      # 0x1dfa6
leaq 0x64e2(%rip), %r9       # 0x1dfd8
xorl %ebp, %ebp
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x19400
addq $0x20, %rsp
jmp 0x17a60
callq 0x18754
leaq 0x1d3ad(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x645e(%rip), %rdx      # 0x1df8b
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
jmp 0x17a5d
// File: /workspace/github_c_makefile_star2_O2/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 0x18754
leaq 0x1d36f(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
leaq 0x655f(%rip), %rdx      # 0x1e0cb
leaq 0x657d(%rip), %r9       # 0x1e0f0
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r9, %r15
xorl %eax, %eax
callq 0x19400
leaq 0x10(%rsp), %r12
pushq $0x8
popq %r13
leaq 0x656d(%rip), %rbx      # 0x1e102
movl %ebp, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd1e0
movq %rax, %r14
callq 0x18754
leaq 0x1d31f(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
pushq %r14
pushq 0x18(%rsp)
callq 0x19400
popq %rcx
popq %rdx
testl %r14d, %r14d
js 0x17c02
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpl $0x8, %r14d
jne 0x17b95
movq 0x8(%rsp), %rdi
movq 0x60(%rdi), %rax
addq $0x18, %rsp
testq %rax, %rax
je 0x17c34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
callq 0x18754
leaq 0x1d2c2(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x650e(%rip), %rdx      # 0x1e126
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 0x19400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17ef4
pushq $0x1
popq %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq $0x23, %r13
ja 0x17f2b
cmpl $0xf, %ebp
jg 0x17f2b
movzbl (%rbx,%r13), %r12d
cmpl $0x2d, %r12d
jne 0x17e8a
cmpl $0x17, %r13d
ja 0x17e8a
movl $0x842100, %eax         # imm = 0x842100
btl %r13d, %eax
jb 0x17eec
callq 0xd450
movq (%rax), %rax
movsbq %r12b, %r15
movzwl (%rax,%r15,2), %eax
btl $0xc, %eax
jae 0x17f2f
btl $0xb, %eax
jb 0x17ebd
callq 0xd440
movq (%rax), %rax
movl (%rax,%r15,4), %r12d
addl $-0x57, %r12d
jmp 0x17ec1
addl $-0x30, %r12d
movslq %ebp, %rax
testl %r14d, %r14d
jne 0x17edd
incl %ebp
andb $0xf, %r12b
movq (%rsp), %rcx
orb %r12b, (%rcx,%rax)
pushq $0x1
popq %r14
jmp 0x17eec
shlb $0x4, %r12b
movq (%rsp), %rcx
movb %r12b, (%rcx,%rax)
xorl %r14d, %r14d
incq %r13
jmp 0x17e5b
callq 0x18754
movq %rax, %r14
leaq 0x1cfcd(%rip), %rax     # 0x34ed0
movq (%rax), %r15
movq %rbx, %rdi
callq 0xd110
leaq 0x5c8d(%rip), %rdx      # 0x1dba2
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x19400
jmp 0x17f53
xorl %eax, %eax
jmp 0x17f56
callq 0x18754
leaq 0x1cf95(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x5c81(%rip), %rdx      # 0x1dbc6
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x193b5
movl 0x10(%rbx), %r9d
leaq 0x1c717(%rip), %rcx     # 0x34ed0
cmpl $0x2, %ebp
jae 0x187f6
movq 0x10(%rcx), %r8
leaq 0x61cb(%rip), %rcx      # 0x1e994
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5f93(%rip), %rdx      # 0x1e76a
xorl %ebp, %ebp
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x19abb
jmp 0x18811
movq (%rcx), %r8
leaq 0x5f45(%rip), %rdx      # 0x1e745
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x193b5
movl 0x10(%rbx), %r9d
leaq 0x1c69d(%rip), %rcx     # 0x34ed0
cmpl $0x2, %ebp
jae 0x18870
movq 0x10(%rcx), %r8
leaq 0x6159(%rip), %rcx      # 0x1e99c
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5f61(%rip), %rdx      # 0x1e7b2
xorl %ebp, %ebp
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x19b2f
jmp 0x1888b
movq (%rcx), %r8
leaq 0x5f15(%rip), %rdx      # 0x1e78f
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1890f
callq *%rax
testl %eax, %eax
je 0x1890f
callq 0x193b5
leaq 0x1c5de(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x5f0b(%rip), %rdx      # 0x1e807
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbx
jmp 0x1893e
callq 0x193b5
leaq 0x1c5b5(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
leaq 0x5f02(%rip), %rdx      # 0x1e828
xorl %ebx, %ebx
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
xorl %edi, %edi
callq 0x19347
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x193b5
leaq 0x1c503(%rip), %r15     # 0x34ed0
movq 0x10(%r15), %r8
leaq 0x5ecd(%rip), %rdx      # 0x1e8a5
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
callq 0x193b5
movq 0x18(%r15), %r8
movl 0x10(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5ec8(%rip), %rdx      # 0x1e8c5
leaq 0x5eeb(%rip), %r14      # 0x1e8ef
pushq $0x3
popq %rbp
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19400
callq 0x193b5
movq 0x18(%r15), %r8
movl 0x14(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5ecf(%rip), %rdx      # 0x1e8fd
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19400
callq 0x193b5
movq 0x18(%r15), %r8
movl 0x18(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5ed5(%rip), %rdx      # 0x1e92a
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19400
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %ecx
callq 0x19ee2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/intel[P]pf-bb-config/daemon.c
// Function: event_init_fd
void event_init_fd(void)
{
	int i;

	LOG(DEBUG, "Event init fd");

	for (i = 0; i < MAX_EVENTS; i++)
		eventFd.fd[i] = -1;
}

// Assembly:
pushq %rbx
callq 0x193b5
leaq 0x1c234(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
leaq 0x576c(%rip), %rdx      # 0x1e413
leaq 0x5780(%rip), %r9       # 0x1e42e
xorl %ebx, %ebx
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
leaq 0x22c72(%rip), %rax     # 0x3b938
cmpq $0x2c, %rbx
je 0x18cd6
orl $-0x1, (%rbx,%rax)
addq $0x4, %rbx
jmp 0x18cc6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x22d8d(%rip)     # 0x3ba70
jle 0x18cfd
callq 0x193b5
leaq 0x1c1df(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x5741(%rip), %rdx      # 0x1e43c
jmp 0x18d31
leaq 0x22c34(%rip), %rax     # 0x3b938
xorl %r14d, %r14d
cmpq $0xb, %r14
je 0x18d1b
cmpl $-0x1, (%rax)
je 0x18d44
incq %r14
addq $0x4, %rax
jmp 0x18d07
callq 0x193b5
leaq 0x1c1a9(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x5761(%rip), %rdx      # 0x1e492
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbx
jmp 0x18d9c
movl %edi, (%rax)
leaq 0x22beb(%rip), %rax     # 0x3b938
movq %rsi, 0x30(%rax,%r14,8)
movq %rdx, 0x88(%rax,%r14,8)
incl 0x22d10(%rip)           # 0x3ba70
callq 0x193b5
leaq 0x1c164(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
movl 0x22cf9(%rip), %r10d    # 0x3ba70
leaq 0x56dc(%rip), %rdx      # 0x1e45a
leaq 0x5700(%rip), %r9       # 0x1e485
xorl %ebx, %ebx
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x19400
popq %rcx
popq %rdx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22b87(%rip), %rax     # 0x3b938
xorl %r14d, %r14d
cmpq $0xb, %r14
je 0x18dc7
cmpl %edi, (%rax)
je 0x18df0
incq %r14
addq $0x4, %rax
jmp 0x18db4
callq 0x193b5
leaq 0x1c0fd(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x56dd(%rip), %rdx      # 0x1e4ba
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbx
jmp 0x18e4b
orl $-0x1, (%rax)
leaq 0x22b3e(%rip), %rax     # 0x3b938
andq $0x0, 0x30(%rax,%r14,8)
andq $0x0, 0x88(%rax,%r14,8)
decl 0x22c61(%rip)           # 0x3ba70
callq 0x193b5
leaq 0x1c0b5(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
movl 0x22c4a(%rip), %r10d    # 0x3ba70
leaq 0x562d(%rip), %rdx      # 0x1e45a
leaq 0x5679(%rip), %r9       # 0x1e4ad
xorl %ebx, %ebx
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x19400
popq %rcx
popq %rdx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
callq 0x193b5
testq %rbx, %rbx
je 0x18f66
leaq 0x1c059(%rip), %r12     # 0x34ed0
movq 0x18(%r12), %r8
leaq 0x56df(%rip), %rdx      # 0x1e562
leaq 0x5702(%rip), %r9       # 0x1e58c
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd390
movl %eax, %r14d
callq 0x193b5
testl %r14d, %r14d
js 0x18f79
movq 0x18(%r12), %r8
subq $0x8, %rsp
leaq 0x56ff(%rip), %rdx      # 0x1e5c4
leaq 0x56c0(%rip), %r9       # 0x1e58c
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r14
callq 0x19400
popq %rcx
popq %rdx
leaq 0x22b92(%rip), %rsi     # 0x3ba78
pushq $0x20
popq %rdx
movl %r14d, %edi
xorl %ecx, %ecx
callq 0xd040
movq %rax, %r15
callq 0x193b5
testl %r15d, %r15d
js 0x18f9a
movq 0x18(%r12), %r8
movswl 0x22b67(%rip), %r10d    # 0x3ba78
movswl 0x22b61(%rip), %r11d    # 0x3ba7a
leaq 0x56ea(%rip), %rdx      # 0x1e60a
leaq 0x5665(%rip), %r9       # 0x1e58c
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x19400
popq %rcx
popq %rdx
movl %r14d, %edi
callq 0xd1b0
movswl 0x22b2d(%rip), %ebp     # 0x3ba78
leaq 0x1bafe(%rip), %r14     # 0x34a50
pushq $0x8
popq %rax
subq $0x1, %rax
jb 0x18fc3
cmpl %ebp, (%r14)
je 0x18fc3
subq $-0x80, %r14
jmp 0x18f55
leaq 0x1bf63(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x555b(%rip), %rdx      # 0x1e4d2
jmp 0x18f84
movq (%r12), %r8
leaq 0x561c(%rip), %rdx      # 0x1e5a0
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x19400
movq (%r12), %r8
leaq 0x5644(%rip), %rdx      # 0x1e5e9
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd1b0
movl (%r14), %r15d
callq 0x193b5
cmpl $-0x1, %r15d
je 0x19024
movq 0x18(%r12), %r8
leaq 0x4(%r14), %r10
movl (%r14), %r11d
leaq 0x5670(%rip), %rdx      # 0x1e654
leaq 0x5690(%rip), %r9       # 0x1e67b
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x19400
popq %rcx
popq %rdx
movq 0x70(%r14), %rax
testq %rax, %rax
je 0x19048
movq %rbx, 0x22a70(%rip)     # 0x3ba80
leaq 0x22a61(%rip), %rsi     # 0x3ba78
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq (%r12), %r8
leaq 0x55fe(%rip), %rdx      # 0x1e62d
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
movl %ebp, %r9d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x19400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18ac3
pushq $-0x1
popq %rbx
testl %eax, %eax
js 0x19086
movl %eax, %ebp
leaq -0x218(%rip), %rsi      # 0x18e55
movl %eax, %edi
movq %r14, %rdx
callq 0x18cd8
testl %eax, %eax
js 0x1907f
movl %ebp, %ebx
jmp 0x19086
movl %ebp, %edi
callq 0xd1b0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2271c(%rip), %ebp     # 0x3ba70
callq 0x193b5
leaq 0x1bb70(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
leaq 0x51cf(%rip), %rdx      # 0x1e53a
xorl %r14d, %r14d
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x19400
leaq 0x225b1(%rip), %rbx     # 0x3b938
movzbl %r14b, %eax
cmpl %eax, %ebp
jbe 0x193a9
movslq 0x226da(%rip), %rax     # 0x3ba70
movl (%rbx,%rax,4), %edi
callq 0xd1b0
decl 0x226cc(%rip)           # 0x3ba70
incb %r14b
jmp 0x19387
movb $0x1, 0x226e8(%rip)     # 0x3ba98
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19459
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, 0x22640(%rip)     # 0x3bac0
je 0x194dd
testl %esi, %esi
leaq 0x2261d(%rip), %rcx     # 0x3baa8
leaq 0x2261e(%rip), %rax     # 0x3bab0
cmoveq %rcx, %rax
cmpl %edi, 0x22604(%rip)     # 0x3baa0
jl 0x194e5
movq (%rax), %r14
testq %r14, %r14
je 0x194f8
movq %r14, %rdi
callq 0xd220
cmpq 0x22603(%rip), %rax     # 0x3bab8
jbe 0x194c3
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd2c0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd380
movl %eax, %ebx
movq %r14, %rdi
callq 0xd290
jmp 0x194fb
cmpl %edi, 0x225bd(%rip)     # 0x3baa0
jge 0x194e9
xorl %ebx, %ebx
jmp 0x194fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2b0
movl %eax, %ebx
jmp 0x194fb
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
testl %r8d, %r8d
je 0x195d7
xorl %r15d, %r15d
cmpq $0x0, 0x2257c(%rip)     # 0x3baa8
jne 0x195fe
movl %r8d, %ebp
movq %rsi, %r12
movq %rdi, %r13
leaq 0x5472(%rip), %rsi      # 0x1e9b4
callq 0xd330
testq %rax, %rax
jne 0x19564
leaq 0x5464(%rip), %rsi      # 0x1e9b7
movq %r13, %rdi
callq 0xd330
testq %rax, %rax
je 0x19610
movq %rax, %r15
leaq 0x5446(%rip), %rsi      # 0x1e9b4
movq %r12, %rdi
callq 0xd330
testq %rax, %rax
jne 0x19593
leaq 0x5435(%rip), %rsi      # 0x1e9b7
movq %r12, %rdi
callq 0xd330
testq %rax, %rax
je 0x1961e
movq %rax, %r13
movq %r15, 0x2250b(%rip)     # 0x3baa8
movq %rax, 0x2250c(%rip)     # 0x3bab0
movq %r14, 0x2250d(%rip)     # 0x3bab8
movl %ebx, 0x224ef(%rip)     # 0x3baa0
movl %ebp, 0x22509(%rip)     # 0x3bac0
movq %r15, %rdi
xorl %r15d, %r15d
pushq $0x2
popq %rbx
xorl %esi, %esi
movl %ebx, %edx
callq 0xd2c0
movq %r13, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0xd2c0
jmp 0x195fe
andq $0x0, 0x224c9(%rip)     # 0x3baa8
andq $0x0, 0x224c9(%rip)     # 0x3bab0
movq %r14, 0x224ca(%rip)     # 0x3bab8
movl %ebx, 0x224ac(%rip)     # 0x3baa0
andl $0x0, 0x224c5(%rip)     # 0x3bac0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53a3(%rip), %rdi      # 0x1e9ba
callq 0xd340
jmp 0x19632
leaq 0x5395(%rip), %rdi      # 0x1e9ba
callq 0xd340
movq %r15, %rdi
callq 0xd0f0
pushq $-0x1
popq %r15
jmp 0x195fe
// File: /workspace/github_c_makefile_star2_O2/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 0xd190
cmpq $0x0, 0x22428(%rip)     # 0x3baa8
je 0x196b2
leaq 0x5346(%rip), %rsi      # 0x1e9cf
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xd3e0
movq %r15, %rdi
callq 0xd140
testl %eax, %eax
jne 0x196db
testl %ebx, %ebx
je 0x196bf
movq 0x22400(%rip), %rdi     # 0x3bab0
jmp 0x196c6
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x223e2(%rip), %rdi     # 0x3baa8
xorl %esi, %esi
xorl %edx, %edx
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd2c0
leaq 0x52fe(%rip), %rdi      # 0x1e9e0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd340
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x197b2
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1976a
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1976a
callq 0x1a231
leaq 0x1b772(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x509f(%rip), %rdx      # 0x1e807
jmp 0x197c8
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x197a0
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x197a0
callq 0x1a231
leaq 0x1b748(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x14c19(%rip), %rdx     # 0x2e3ab
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq %rbx, %rdi
callq 0x197db
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x197d9
callq 0x1a231
leaq 0x1b712(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x14bcd(%rip), %rdx     # 0x2e395
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
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 0x1981e
callq 0x1a231
leaq 0x1b6cf(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x14f72(%rip), %rdx     # 0x2e77d
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $-0x1
popq %rbp
jmp 0x19886
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x19848
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19848
callq 0x1a231
leaq 0x1b694(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x1cbe(%rip), %rdx      # 0x1b504
jmp 0x1980b
callq 0x1a231
leaq 0x1b67c(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
movq (%rbx), %r9
leaq 0x20(%rbx), %rcx
movq %rcx, (%rsp)
leaq 0x14f31(%rip), %rdx     # 0x2e79b
xorl %ebp, %ebp
pushq $0x2
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x19a78
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a231
leaq 0x1b62e(%rip), %r14     # 0x34ed0
movq 0x18(%r14), %r8
leaq 0x14b19(%rip), %rdx     # 0x2e3c6
leaq 0x14b3a(%rip), %r9      # 0x2e3ee
xorl %ebp, %ebp
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
testq %rbx, %rbx
je 0x19965
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x198ff
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x198ff
callq 0x1a231
movq (%r14), %r8
leaq 0x4f18(%rip), %rdx      # 0x1e807
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
jmp 0x19938
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1990f
movq %rbx, %rdi
callq *%rax
jmp 0x1992c
callq 0x1a231
movq (%r14), %r8
leaq 0x14af2(%rip), %rdx     # 0x2e410
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq %rbx, %rdi
callq 0x197db
testl %eax, %eax
je 0x1993d
pushq $-0x1
popq %rbp
jmp 0x19965
callq 0x1a231
movq 0x18(%r14), %r8
leaq 0x1bd7(%rip), %rdx      # 0x1b524
leaq 0x14a9a(%rip), %r9      # 0x2e3ee
xorl %ebp, %ebp
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a231
leaq 0x1b551(%rip), %r14     # 0x34ed0
movq 0x18(%r14), %r8
leaq 0x14a3c(%rip), %rdx     # 0x2e3c6
leaq 0x14aa5(%rip), %r9      # 0x2e436
xorl %ebp, %ebp
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
testq %rbx, %rbx
je 0x19a71
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x199dc
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x199dc
callq 0x1a231
movq (%r14), %r8
leaq 0x4e3b(%rip), %rdx      # 0x1e807
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
jmp 0x19a44
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x199ec
movq %rbx, %rdi
callq *%rax
jmp 0x19a09
callq 0x1a231
movq (%r14), %r8
leaq 0x14a15(%rip), %rdx     # 0x2e410
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x19a38
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x19a38
callq 0x1a231
movq (%r14), %r8
leaq 0x14981(%rip), %rdx     # 0x2e3ab
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq %rbx, %rdi
callq 0x197db
testl %eax, %eax
je 0x19a49
pushq $-0x1
popq %rbp
jmp 0x19a71
callq 0x1a231
movq 0x18(%r14), %r8
leaq 0x1acb(%rip), %rdx      # 0x1b524
leaq 0x149d6(%rip), %r9      # 0x2e436
xorl %ebp, %ebp
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
xorl %ecx, %ecx
pushq $0x3
popq %rdx
cmpq $0x40, %rcx
je 0x19aba
movq %rax, %r8
cmpl $0x3, %esi
jne 0x19aad
cmpq $0x5, 0xf0(%rdi,%rcx,8)
movq %rdx, %r8
jne 0x19aad
xorl %r8d, %r8d
cmpl $0x1, 0x4f4(%rdi)
sete %r8b
xorq $0x7, %r8
movq %r8, 0xf0(%rdi,%rcx,8)
incq %rcx
jmp 0x19a7f
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x1a231
leaq 0x1b3fc(%rip), %r12     # 0x34ed0
movq 0x18(%r12), %r8
leaq 0x1497c(%rip), %rdx     # 0x2e45c
leaq 0x14995(%rip), %r15     # 0x2e47c
pushq $0x3
popq %rbp
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19400
movl %ebx, 0x4f4(%r14)
callq 0x1a231
movq 0x18(%r12), %r8
leaq 0x1a11(%rip), %rdx      # 0x1b524
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19400
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x1a231
leaq 0x1b388(%rip), %r12     # 0x34ed0
movq 0x18(%r12), %r8
leaq 0x1493a(%rip), %rdx     # 0x2e48e
leaq 0x14959(%rip), %r15     # 0x2e4b4
pushq $0x3
popq %rbp
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19400
movl %ebx, 0x4f0(%r14)
callq 0x1a231
movq 0x18(%r12), %r8
leaq 0x199d(%rip), %rdx      # 0x1b524
movl %ebp, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19400
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15c5(%rip), %rsi      # 0x1b17b
leaq 0x15d2(%rip), %rdx      # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3e0
callq 0x1a231
leaq 0x1b2f8(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x148dd(%rip), %rdx     # 0x2e4c4
leaq 0x148f1(%rip), %r9      # 0x2e4df
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19658
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1575(%rip), %rsi      # 0x1b198
leaq 0x1565(%rip), %rdx      # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3e0
callq 0x1a231
leaq 0x1b28b(%rip), %rcx     # 0x34ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x1489a(%rip), %rdx     # 0x2e4ee
leaq 0x148b1(%rip), %r9      # 0x2e50c
pushq $0x3
popq %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x19658
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %ebx
shlq $0x4, %rbx
pushq $0x1
popq %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x19cf4
movq 0xb0(%r15), %rax
movl 0x8(%r14,%r12), %ecx
movl (%rax,%rcx), %ebp
callq 0x1a231
leaq 0x1b20d(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
movq (%r14,%r12), %r9
movl 0x8(%r14,%r12), %r10d
pushq $0x2
popq %rdi
movl %r13d, %esi
leaq 0x14843(%rip), %rdx     # 0x2e520
movq %rax, %rcx
xorl %eax, %eax
pushq %rbp
pushq %r10
callq 0x19400
addq $0x10, %rsp
addq $0x10, %r12
jmp 0x19ca3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %ebx
shlq $0x4, %rbx
pushq $0x1
popq %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x19d7b
movq 0xb0(%r15), %rax
movl 0x8(%r14,%r12), %ecx
movl (%rax,%rcx), %ebp
callq 0x1a231
leaq 0x1b186(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
movq (%r14,%r12), %r9
movl 0x8(%r14,%r12), %r10d
pushq $0x2
popq %rdi
movl %r13d, %esi
leaq 0x147bc(%rip), %rdx     # 0x2e520
movq %rax, %rcx
xorl %eax, %eax
pushq %rbp
pushq %r10
callq 0x19400
addq $0x10, %rsp
addq $0x10, %r12
jmp 0x19d2a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19e53
movl %esi, %ebp
movq %rdi, %rbx
callq 0x19c10
cmpl $0x57c2, %ebp           # imm = 0x57C2
je 0x19e77
cmpl $0x57c0, %ebp           # imm = 0x57C0
je 0x19e61
cmpl $0xd5c, %ebp            # imm = 0xD5C
jne 0x19e8d
leaq 0x1b0ac(%rip), %rsi     # 0x34ef0
movq %rbx, %rdi
movl $0x308, %edx            # imm = 0x308
callq 0x19c7e
jmp 0x19eb2
leaq 0x1496d(%rip), %rdi     # 0x2e7c7
callq 0xd0c0
jmp 0x19ed9
leaq 0x1e108(%rip), %rsi     # 0x37f70
movq %rbx, %rdi
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x19d05
jmp 0x19eb2
leaq 0x20002(%rip), %rsi     # 0x39e80
movq %rbx, %rdi
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x19d8c
jmp 0x19eb2
callq 0x1a231
leaq 0x1b037(%rip), %rcx     # 0x34ed0
movq (%rcx), %r8
leaq 0x14699(%rip), %rdx     # 0x2e53c
pushq $0x1
popq %rsi
xorl %edi, %edi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
callq 0x1a231
leaq 0x1b012(%rip), %rcx     # 0x34ed0
movq 0x10(%rcx), %r8
leaq 0x14695(%rip), %rdx     # 0x2e55e
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19400
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq