LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_enable_intr
int vrb2_enable_intr(void *dev)
{
	int ret;
	hw_device *accel_pci_dev = (hw_device *)dev;
	void *bar0addr = accel_pci_dev->bar0Addr;

	LOG(DEBUG, "Enable VRB2 interrupts");
	/* allocate info ring */
	ret = vrb2_allocate_info_ring(dev);
	if (ret < 0) {
		LOG(ERR, "vrb2allocate info ring failed");
		return -1;
	}

	vrb2_enable_ir_regs(bar0addr);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1bd70
movq %rax, %rcx
leaq 0x21fce(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0xb69a(%rip), %rdx      # 0x24fae
leaq 0xb6b7(%rip), %r9       # 0x24fd2
movb $0x0, %al
callq 0x216e0
movq -0x10(%rbp), %rdi
callq 0x199b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x19961
callq 0x1bd70
movq %rax, %rcx
leaq 0x21f8d(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0xb694(%rip), %rdx      # 0x24fe3
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x199a0
movq -0x28(%rbp), %rdi
callq 0x19bb0
callq 0x1bd70
movq %rax, %rcx
leaq 0x21f57(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x9d37(%rip), %rdx      # 0x236c2
leaq 0xb640(%rip), %r9       # 0x24fd2
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_enable_ir_regs
static void
vrb2_enable_ir_regs(uint8_t *bar0addr)
{
	/* Enabling all interrupt and IR */
	vrb2_reg_write(bar0addr, HWPfHiInfoRingIntWrEnRegPf, 0xFFFFFFFF);
	vrb2_reg_write(bar0addr, HWPfHiCfgMsiIntWrEnRegPf, 0xFFFFFFFF);
	vrb2_reg_write(bar0addr, HWPfHiInfoRingVf2pfHiWrEnReg, 0xFFFFFFFF);
	vrb2_reg_write(bar0addr, HWPfHiInfoRingVf2pfLoWrEnReg, 0xFFFFFFFF);
	vrb2_reg_write(bar0addr, HWPfHiCfgMsiVf2pfHighWrEnReg, 0xFFFFFFFF);
	vrb2_reg_write(bar0addr, HWPfHiCfgMsiVf2pfLoWrEnReg, 0xFFFFFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc84020, %esi         # imm = 0xC84020
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
movq -0x8(%rbp), %rdi
movl $0xc84040, %esi         # imm = 0xC84040
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
movq -0x8(%rbp), %rdi
movl $0xc84028, %esi         # imm = 0xC84028
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
movq -0x8(%rbp), %rdi
movl $0xc84024, %esi         # imm = 0xC84024
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
movq -0x8(%rbp), %rdi
movl $0xc84048, %esi         # imm = 0xC84048
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
movq -0x8(%rbp), %rdi
movl $0xc84044, %esi         # imm = 0xC84044
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x197e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_disable_intr
int
vrb2_disable_intr(void *dev)
{
	hw_device *accel_pci_dev = (hw_device *)dev;
	void *bar0addr = accel_pci_dev->bar0Addr;

	LOG(DEBUG, "Disable interrupts");

	vrb2_disable_ir_regs(bar0addr);

	vrb2_free_info_ring(dev);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1bd70
movq %rax, %rcx
leaq 0x21c5e(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0xa661(%rip), %rdx      # 0x242e5
leaq 0xb37d(%rip), %r9       # 0x25008
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rdi
callq 0x19760
movq -0x8(%rbp), %rdi
callq 0x19ce0
callq 0x1bd70
movq %rax, %rcx
leaq 0x21c1d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x99fd(%rip), %rdx      # 0x236c2
leaq 0xb33c(%rip), %r9       # 0x25008
movb $0x0, %al
callq 0x216e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_configure
int
vrb2_configure(void *dev, void *bar0addr, const char *cfg_filename, const bool first_cfg)
{
	struct vrb2_conf vrb2_conf;
	int ret;

	ret = vrb2_read_config_file(cfg_filename, &vrb2_conf);
	if (ret != 0) {
		LOG(ERR, "Error reading config file.");
		return -1;
	}

	ret = vrb2_write_config(dev, bar0addr, &vrb2_conf, first_cfg);
	if (ret != 0) {
		LOG(ERR, "Error writing configuration for VRB2.");
		return -1;
	}
	hw_device *accel_dev = (hw_device *)dev;
	accel_dev->numvfs = vrb2_conf.num_vf_bundles;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1260, %rsp           # imm = 0x1260
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x1250(%rbp), %rsi
callq 0x19eb0
movl %eax, -0x1254(%rbp)
cmpl $0x0, -0x1254(%rbp)
je 0x19e1a
callq 0x1bd70
movq %rax, %rcx
leaq 0x21ad4(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0xb212(%rip), %rdx      # 0x2501a
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19e98
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x21(%rbp), %al
leaq -0x1250(%rbp), %rdx
andb $0x1, %al
movzbl %al, %ecx
callq 0x19f30
movl %eax, -0x1254(%rbp)
cmpl $0x0, -0x1254(%rbp)
je 0x19e72
callq 0x1bd70
movq %rax, %rcx
leaq 0x21a7c(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0xb1dc(%rip), %rdx      # 0x2503c
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19e98
movq -0x10(%rbp), %rax
movq %rax, -0x1260(%rbp)
movzwl -0x124c(%rbp), %ecx
movq -0x1260(%rbp), %rax
movl %ecx, 0x4f8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1260, %rsp           # imm = 0x1260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_read_config_file
static int
vrb2_read_config_file(const char *arg_cfg_filename,
		struct vrb2_conf *vrb2_conf)
{
	bool unsafe_path = cfg_file_check_path_safety(arg_cfg_filename);
	if (unsafe_path == true) {
		LOG(ERR, "config file path \"%s\" is not safe", arg_cfg_filename);
		return -1;
	} else
		return vrb2_parse_conf_file(arg_cfg_filename, vrb2_conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17fc0
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x19f0c
callq 0x1bd70
movq %rax, %rcx
leaq 0x219e6(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x10(%rbp), %r9
xorl %esi, %esi
leaq 0x9979(%rip), %rdx      # 0x23873
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19f1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c7b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_disable_int_src
static void vrb2_disable_int_src(uint8_t *bar0addr, int int_src)
{
	uint32_t mask;

	mask = vrb2_reg_read(bar0addr, HWPfHiInfoRingIntWrEnRegPf);
	mask &= (0xFFFFFFFF - (1ULL << int_src));
	LOG(INFO, "Disable the Interrupt source %d new mask %x", int_src, mask);
	vrb2_reg_write(bar0addr, HWPfHiInfoRingIntWrEnRegPf, mask);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc84020, %esi         # imm = 0xC84020
callq 0x18b70
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
subq %rax, %rcx
movl -0x10(%rbp), %eax
andq %rcx, %rax
movl %eax, -0x10(%rbp)
callq 0x1bd70
movq %rax, %rcx
leaq 0x1f883(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %eax
movl $0x2, %edi
xorl %esi, %esi
leaq 0x9392(%rip), %rdx      # 0x253f8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl $0xc84020, %esi         # imm = 0xC84020
callq 0x197e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_db_write
static void
vrb2_db_write(void *dev, unsigned int vf_index, uint32_t msg)
{
	hw_device *accel_dev = (hw_device *)dev;
	uint8_t *bar0addr = accel_dev->bar0Addr;

	vrb2_reg_fast_write(bar0addr, HWPfHiPfToVfDbellVf
				+ vf_index * BB_ACC_PF_TO_VF_DBELL_REG_OFFSET,
				msg);
	/* Dummy write to prevent back to back DB. */
	vrb2_reg_fast_write(bar0addr, HWPfHiModuleVersionReg, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
shll $0x8, %esi
addl $0xc80008, %esi         # imm = 0xC80008
movl -0x10(%rbp), %edx
callq 0x1bfd0
movq -0x20(%rbp), %rdi
movl $0xc84000, %esi         # imm = 0xC84000
xorl %edx, %edx
callq 0x1bfd0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_parser.c
// Function: vrb2_queue_range_check
int
vrb2_queue_range_check(struct q_topology_t q_conf)
{
	if ((q_conf.num_aqs_per_groups < 1) ||
			(q_conf.num_aqs_per_groups > VRB2_NUM_AQS)) {
		printf("ERROR: Number of AQs out of range %d\n",
				q_conf.num_aqs_per_groups);
		return -1;
	}
	if ((q_conf.aq_depth_log2 < 1) ||
			(q_conf.aq_depth_log2 > VRB2_MAX_QDEPTH)) {
		printf("ERROR: AQ Depth out of range %d\n",
				q_conf.aq_depth_log2);
		return -1;
	}
	if (q_conf.num_qgroups > VRB2_NUM_QGRPS) {
		printf("ERROR: Number of QG out of range %d\n",
				q_conf.num_qgroups);
		return -1;
	}
	if (q_conf.num_qgroups * q_conf.num_aqs_per_groups > VRB2_MAX_QGRPS_PER_OP) {
		printf("ERROR: Number of queues per op out of range %d %d\n",
				q_conf.num_qgroups * q_conf.num_aqs_per_groups,
				VRB2_MAX_QGRPS_PER_OP);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, %eax
movl %eax, -0xa(%rbp)
shrq $0x20, %rdi
movw %di, %ax
movw %ax, -0x6(%rbp)
movzwl -0x8(%rbp), %eax
cmpl $0x1, %eax
jl 0x1c4ea
movzwl -0x8(%rbp), %eax
cmpl $0x40, %eax
jle 0x1c508
movzwl -0x8(%rbp), %esi
leaq 0x768b(%rip), %rdi      # 0x23b80
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c599
movzwl -0x6(%rbp), %eax
cmpl $0x1, %eax
jl 0x1c51a
movzwl -0x6(%rbp), %eax
cmpl $0x8, %eax
jle 0x1c535
movzwl -0x6(%rbp), %esi
leaq 0x7681(%rip), %rdi      # 0x23ba6
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c599
movzwl -0xa(%rbp), %eax
cmpl $0x20, %eax
jle 0x1c559
movzwl -0xa(%rbp), %esi
leaq 0x767e(%rip), %rdi      # 0x23bc7
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c599
movzwl -0xa(%rbp), %eax
movzwl -0x8(%rbp), %ecx
imull %ecx, %eax
cmpl $0x100, %eax            # imm = 0x100
jle 0x1c592
movzwl -0xa(%rbp), %esi
movzwl -0x8(%rbp), %eax
imull %eax, %esi
leaq 0x9363(%rip), %rdi      # 0x258e0
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c599
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/vrb2/vrb2_cfg_parser.c
// Function: vrb2_parse_conf_file
int
vrb2_parse_conf_file(const char *file_name, struct vrb2_conf *vrb2_conf)
{
	int ret;

	set_default_config(vrb2_conf);

	ret = cfg_parse(file_name, vrb2_handler, vrb2_conf);
	if (ret != 0) {
		printf("ERROR: Config file parser error\n");
		set_default_config(vrb2_conf);
		return -1;
	}

	ret = vrb2_range_check(vrb2_conf);
	if (ret != 0) {
		printf("ERROR: Parameter out of range\n");
		set_default_config(vrb2_conf);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c850
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c8(%rip), %rsi       # 0x1cba0
callq 0x17f40
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1c806
leaq 0x7446(%rip), %rdi      # 0x23c33
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x1c850
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c83f
movq -0x18(%rbp), %rdi
callq 0x1c5b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1c838
leaq 0x7435(%rip), %rdi      # 0x23c54
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x1c850
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c83f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/agx100/agx100_cfg_app.c
// Function: agx100_configure
int
agx100_configure(void *dev, void *bar0addr, const char *cfg_filename, const bool first_cfg)
{
	struct agx100_conf agx100_conf;
	int ret;

	ret = agx100_read_config_file(cfg_filename, &agx100_conf);
	if (ret != 0) {
		printf("Error reading config file.\n");
		return -1;
	}

	ret = agx100_write_config(dev, bar0addr, &agx100_conf);
	if (ret != 0) {
		printf("Error writing configuration for AGX100.\n");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x1dc90
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x1dc48
leaq 0x73e8(%rip), %rdi      # 0x25020
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dc80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x1dcf0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x1dc79
leaq 0x7cb6(%rip), %rdi      # 0x2591f
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dc80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/agx100/agx100_cfg_app.c
// Function: agx100_read_config_file
static int
agx100_read_config_file(const char *arg_cfg_filename,
		struct agx100_conf *agx100_conf)
{
	bool unsafe_path = cfg_file_check_path_safety(arg_cfg_filename);
	if (unsafe_path == true) {
		printf("error, config file path \"%s\" is not safe",
				arg_cfg_filename);
		return -1;
	} else
		return agx100_parse_conf_file(arg_cfg_filename,
				agx100_conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17fc0
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1dcd6
movq -0x10(%rbp), %rsi
leaq 0x6181(%rip), %rdi      # 0x23e47
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dce6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e380
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e420
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xd8(%rip), %rsi        # 0x1e480
callq 0x17f40
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1e3da
movq -0x10(%rbp), %rsi
leaq 0x5cb3(%rip), %rdi      # 0x24074
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x1e420
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1e409
cmpl $-0x2, -0x1c(%rbp)
jne 0x1e400
leaq 0x5cb9(%rip), %rdi      # 0x240a0
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x1e420
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x1e409
jmp 0x1e402
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/agx100/agx100_cfg_parser.c
// Function: set_default_config
static void
set_default_config(struct agx100_conf *agx100_conf)
{
	int i;

	/* Set pf mode to true */
	agx100_conf->pf_mode_en = DEFAULT_PF_MODE_EN;

	/* Set Load Balance Factor to 64 */
	agx100_conf->ul_load_balance = DEFAULT_UL_LOAD_BALANCE;
	agx100_conf->dl_load_balance = DEFAULT_DL_LOAD_BALANCE;

	for (i = 0; i < AGX100_NUM_VFS; i++) {
		agx100_conf->vf_ul_queues_number[i] = DEFAULT_NUM_VF_QUEUE / 2;
		agx100_conf->vf_dl_queues_number[i] = DEFAULT_NUM_VF_QUEUE / 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movb $0x40, 0x11(%rax)
movq -0x8(%rbp), %rax
movb $0x40, 0x12(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x1e471
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x4, 0x1(%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x4, 0x9(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e446
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_read
int vfio_read(int fd, void *buf, size_t len, off_t off)
{
	if (pread(fd, buf, len, off) != len) {
		LOG(ERR, "pread(off=%#lx len=%lu)", off, len);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xd3c0
cmpq -0x18(%rbp), %rax
je 0x1e88a
callq 0x20230
movq %rax, %rcx
leaq 0x1d070(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
xorl %esi, %esi
leaq 0x715e(%rip), %rdx      # 0x259d2
movl %esi, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e891
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_write
int vfio_write(int fd, void *buf, size_t len, off_t off)
{
	if (pwrite(fd, buf, len, off) != len) {
		LOG(ERR, "pwrite(off=%#lx len=%lu)", off, len);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xd2d0
cmpq -0x18(%rbp), %rax
je 0x1e90a
callq 0x20230
movq %rax, %rcx
leaq 0x1cff0(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
xorl %esi, %esi
leaq 0x70fd(%rip), %rdx      # 0x259f1
movl %esi, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e911
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_device_reset
int vfio_device_reset(void *dev)
{
	hw_device *hwd = (hw_device *)dev;

	LOG(DEBUG, "VFIO device reset:");

	if (ioctl(hwd->vfio_dev_fd, VFIO_DEVICE_RESET)) {
		LOG(DEBUG, "VFIO_DEVICE_RESET ioctl failed");
		return -1;
	}

	LOG(DEBUG, "Done");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x20230
movq %rax, %rcx
leaq 0x1cf8d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x70bc(%rip), %rdx      # 0x25a11
leaq 0x70d5(%rip), %r9       # 0x25a31
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %edi
movl $0x3b6f, %esi           # imm = 0x3B6F
movb $0x0, %al
callq 0xd180
cmpl $0x0, %eax
je 0x1e9b6
callq 0x20230
movq %rax, %rcx
leaq 0x1cf43(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x70a4(%rip), %rdx      # 0x25a43
leaq 0x708b(%rip), %r9       # 0x25a31
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e9ec
callq 0x20230
movq %rax, %rcx
leaq 0x1cf0b(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x4ceb(%rip), %rdx      # 0x236c2
leaq 0x7053(%rip), %r9       # 0x25a31
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x20230
movq %rax, %rcx
leaq 0x1c87a(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x7055(%rip), %rdx      # 0x260bd
leaq 0x7073(%rip), %r9       # 0x260e2
movb $0x0, %al
callq 0x216e0
movl -0x4(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0xd1c0
movl %eax, -0x1c(%rbp)
callq 0x20230
movq %rax, %rcx
leaq 0x1c837(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x28(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x7042(%rip), %rdx      # 0x260f4
leaq 0x7029(%rip), %r9       # 0x260e2
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
cmpl $0x0, -0x1c(%rbp)
jge 0x1f0f4
callq 0x20230
movq %rax, %rcx
leaq 0x1c7f3(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x702f(%rip), %rdx      # 0x26118
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
jmp 0x1f11d
jmp 0x1f0f6
movslq -0x1c(%rbp), %rax
cmpq $0x8, %rax
jne 0x1f076
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1f11d
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_disable_intr
int vfio_disable_intr(void *dev)
{
	hw_device *hwd = (hw_device *)dev;

	LOG(DEBUG, "VFIO disable interrupts");

	if (!hwd->vfio_mode)
		return 0;

	switch (hwd->vfio_int_mode) {
	case VFIO_PCI_MSI_IRQ_INDEX:
		if ((hwd->ops.dev_disable_intr) && (hwd->ops.dev_disable_intr(hwd))) {
			LOG(ERR, "vfio enable %s device intr failed", hwd->device_name);
			return -1;
		}

		if (vfio_disable_msi(hwd))
			LOG(ERR, "vfio disable MSI intr failed");

		/* deregister isr callback for intr event */
		event_del_fd(hwd->irq_event_fd);
		close(hwd->irq_event_fd);
		hwd->irq_event_fd = 0;
		break;

	case VFIO_PCI_INTX_IRQ_INDEX:
	case VFIO_PCI_MSIX_IRQ_INDEX:
	case VFIO_PCI_ERR_IRQ_INDEX:
	default:
		LOG(INFO, "Not supported irq index (%d)", hwd->vfio_int_mode);
		break;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x20230
movq %rax, %rcx
leaq 0x1c77d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x69d4(%rip), %rdx      # 0x25b39
leaq 0x69f2(%rip), %r9       # 0x25b5e
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
cmpl $0x0, 0xbc(%rax)
jne 0x1f18c
movl $0x0, -0x4(%rbp)
jmp 0x1f2e1
movq -0x18(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x1f276
jmp 0x1f1a3
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x1f1c1
jmp 0x1f1ad
movl -0x1c(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x1f276
jmp 0x1f278
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1f216
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x1f216
callq 0x20230
movq %rax, %rcx
leaq 0x1c6e2(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x18(%rbp), %rax
movq (%rax), %r9
xorl %esi, %esi
leaq 0x68eb(%rip), %rdx      # 0x25aec
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f2e1
movq -0x18(%rbp), %rdi
callq 0x1f2f0
cmpl $0x0, %eax
je 0x1f248
callq 0x20230
movq %rax, %rcx
leaq 0x1c69d(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x6931(%rip), %rdx      # 0x25b70
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movl 0xc4(%rax), %edi
callq 0x20d10
movq -0x18(%rbp), %rax
movl 0xc4(%rax), %edi
callq 0xd190
movq -0x18(%rbp), %rax
movl $0x0, 0xc4(%rax)
jmp 0x1f2ab
jmp 0x1f278
callq 0x20230
movq %rax, %rcx
leaq 0x1c649(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x18(%rbp), %rax
movl 0xc8(%rax), %r9d
movl $0x2, %edi
xorl %esi, %esi
leaq 0x6871(%rip), %rdx      # 0x25b15
movb $0x0, %al
callq 0x216e0
callq 0x20230
movq %rax, %rcx
leaq 0x1c616(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x43f6(%rip), %rdx      # 0x236c2
leaq 0x688b(%rip), %r9       # 0x25b5e
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_disable_msi
static int vfio_disable_msi(hw_device *hwd)
{
	int len;
	char  set_irq_buf[VFIO_IRQ_SET_BUF_LEN];
	struct vfio_irq_set *irqs;

	LOG(DEBUG, "MSI IRQ event deregistration");

	/* if not registred, do nothing */
	if (hwd->irq_event_fd == 0)
		return 0;

	LOG(DEBUG, "irq_event_fd: %d", hwd->irq_event_fd);

	len = sizeof(struct vfio_irq_set);

	irqs = (struct vfio_irq_set *)set_irq_buf;
	irqs->argsz = len;
	irqs->index = VFIO_PCI_MSI_IRQ_INDEX;
	irqs->flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER;
	irqs->start = 0;
	irqs->count = 1;

	if (ioctl(hwd->vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irqs)) {
		LOG(ERR, "ioctl VFIO_DEVICE_SET_IRQS error");
		return -1;
	}

	LOG(DEBUG, "irq eventfd deregistration success");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
callq 0x20230
movq %rax, %rcx
leaq 0x1c5c5(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x6e1f(%rip), %rdx      # 0x2613c
leaq 0x6e42(%rip), %r9       # 0x26166
movb $0x0, %al
callq 0x216e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
jne 0x1f344
movl $0x0, -0x4(%rbp)
jmp 0x1f446
callq 0x20230
movq %rax, %rcx
leaq 0x1c57d(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x10(%rbp), %rax
movl 0xc4(%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x6cd7(%rip), %rdx      # 0x26046
leaq 0x6df0(%rip), %r9       # 0x26166
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
movl $0x14, -0x14(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x21, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edi
movq -0x38(%rbp), %rdx
movl $0x3b6e, %esi           # imm = 0x3B6E
movb $0x0, %al
callq 0xd180
cmpl $0x0, %eax
je 0x1f410
callq 0x20230
movq %rax, %rcx
leaq 0x1c4de(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x6d79(%rip), %rdx      # 0x26177
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f446
callq 0x20230
movq %rax, %rcx
leaq 0x1c4b1(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x6d6e(%rip), %rdx      # 0x2619f
leaq 0x6d2e(%rip), %r9       # 0x26166
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_get_device_groupid
static int vfio_get_device_groupid(const char *pci_addr)
{
	char device_iommu_group[PATH_MAX];
	char group_path[PATH_MAX];
	char *group_name;
	int groupid = -1;
	int len;

	snprintf(device_iommu_group, sizeof(device_iommu_group),
			"%s/%s/iommu_group", SYS_DIR, pci_addr);
	len = readlink(device_iommu_group, group_path, sizeof(group_path) - 1);
	if (len < 0) {
		LOG(ERR, "VFIO: iommu_group error for %s", pci_addr);
		return -1;
	}
	group_path[len] = 0;

	group_name = basename(group_path);
	groupid = strtol(group_name, NULL, 10);
	if (groupid == 0) {
		LOG(ERR, "VFIO: Faild to read %s", group_path);
		return -1;
	}

	return groupid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x201c(%rbp) # imm = 0xFFFFFFFF
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0x64ef(%rip), %rdx      # 0x261cf
leaq 0x362f(%rip), %rcx      # 0x23316
movb $0x0, %al
callq 0xd160
leaq -0x1010(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0xd0c0
movl %eax, -0x2020(%rbp)
cmpl $0x0, -0x2020(%rbp)
jge 0x1fd49
callq 0x20230
movq %rax, %rcx
leaq 0x1bbac(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x10(%rbp), %r9
xorl %esi, %esi
leaq 0x64ad(%rip), %rdx      # 0x261e1
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1fdcc
movslq -0x2020(%rbp), %rax
movb $0x0, -0x2010(%rbp,%rax)
leaq -0x2010(%rbp), %rdi
callq 0xd240
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xd220
movl %eax, -0x201c(%rbp)
cmpl $0x0, -0x201c(%rbp)
jne 0x1fdc3
callq 0x20230
movq %rax, %rcx
leaq 0x1bb32(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
leaq -0x2010(%rbp), %r9
xorl %esi, %esi
leaq 0x6456(%rip), %rdx      # 0x26207
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1fdcc
movl -0x201c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_dma_alloc
void *vfio_dma_alloc(void *dev, size_t size, uint64_t *phy)
{
	hw_device *hwd = (hw_device *)dev;

	if (hwd->iommu_map_dma_size < size)
		return NULL;

	/* using va as iova */
	*phy = (uint64_t)(hwd->iommu_map_dma_vaddr);

	return hwd->iommu_map_dma_vaddr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq 0xd8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x201e3
movq $0x0, -0x8(%rbp)
jmp 0x20204
movq -0x28(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: uuid_unparse
static void uuid_unparse(unsigned char *uuid, char *uuid_str)
{
	char *ptr = uuid_str;
	int temp;
	int i;

	for (i = 0; i < VFIO_VF_TOKEN_LEN; i++) {
		if (i == 4 || i == 6 || i == 8 || i == 10)
			*ptr++ = '-';

		temp = (uuid[i] >> 4) & 0xF;
		*ptr++ = (temp < 10) ? temp + '0' : 'a' + (temp - 10);
		temp = (uuid[i] & 0xF);
		*ptr++ = (temp < 10) ? temp + '0' : 'a' + (temp - 10);
	}
	*ptr = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x10, -0x20(%rbp)
jge 0x203aa
cmpl $0x4, -0x20(%rbp)
je 0x202fd
cmpl $0x6, -0x20(%rbp)
je 0x202fd
cmpl $0x8, -0x20(%rbp)
je 0x202fd
cmpl $0xa, -0x20(%rbp)
jne 0x2030f
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x20335
movl -0x1c(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0x20341
movl -0x1c(%rbp), %eax
subl $0xa, %eax
addl $0x61, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x2037a
movl -0x1c(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x28(%rbp)
jmp 0x20386
movl -0x1c(%rbp), %eax
subl $0xa, %eax
addl $0x61, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x202db
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq 0x19995(%rip), %rax     # 0x39d80
movq %rax, -0x40(%rbp)
movq 0x19992(%rip), %rax     # 0x39d88
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20440
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
je 0x20440
callq 0x21530
movq %rax, %rcx
leaq 0x1b4b5(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x28(%rbp), %rax
movl (%rax), %r9d
xorl %esi, %esi
leaq 0x6323(%rip), %rdx      # 0x26751
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2048d
callq 0x21530
movq %rax, %rcx
leaq 0x1b481(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x40(%rbp,%rax,8), %r9
movl $0x2, %edi
xorl %esi, %esi
leaq 0x630a(%rip), %rdx      # 0x26776
movb $0x0, %al
callq 0x216e0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x220a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq 0x198c5(%rip), %rax     # 0x39d90
movq %rax, -0x40(%rbp)
movq 0x198c2(%rip), %rax     # 0x39d98
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x20520
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
je 0x20520
callq 0x21530
movq %rax, %rcx
leaq 0x1b3d5(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x28(%rbp), %rax
movl (%rax), %r9d
xorl %esi, %esi
leaq 0x628d(%rip), %rdx      # 0x2679b
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2056d
callq 0x21530
movq %rax, %rcx
leaq 0x1b3a1(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x40(%rbp,%rax,8), %r9
movl $0x2, %edi
xorl %esi, %esi
leaq 0x6272(%rip), %rdx      # 0x267be
movb $0x0, %al
callq 0x216e0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x22130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: clear_log_exec
static int
clear_log_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;

	LOG(DEBUG, "clear_log command received");

	clear_log_file(cmd_req->priv);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1b329(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x6223(%rip), %rdx      # 0x267dc
leaq 0x6244(%rip), %r9       # 0x26804
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x221c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2064f
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x2064f
callq 0x21530
movq %rax, %rcx
leaq 0x1b29f(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x61d6(%rip), %rdx      # 0x26813
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20685
callq 0x21530
movq %rax, %rcx
leaq 0x1b272(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
xorl %esi, %esi
leaq 0x61c4(%rip), %rdx      # 0x26834
movb $0x0, %al
callq 0x216e0
xorl %edi, %edi
callq 0x21300
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: reg_dump_exec
static int
reg_dump_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct reg_dump_req *reg_dump = (struct reg_dump_req *)CMD_REQ(ci);

	LOG(INFO, "reg_dump command received,  device_id : 0x%x", reg_dump->device_id);

	acc_reg_dump(cmd_req->priv, reg_dump->device_id);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1b20d(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movq -0x20(%rbp), %rax
movl (%rax), %r9d
movl $0x2, %edi
xorl %esi, %esi
leaq 0x6179(%rip), %rdx      # 0x26855
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x225a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: reconfigure_acc_exec
static int
reconfigure_acc_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;

	LOG(INFO, "reconfigure_acc command received");

	bb_acc_dev_reset_and_reconfig(cmd_req->priv);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1b1a9(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
xorl %esi, %esi
leaq 0x6150(%rip), %rdx      # 0x26889
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21b20
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1b13d(%rip), %rax     # 0x3b8d0
movq 0x10(%rax), %r8
movl $0x2, %edi
xorl %esi, %esi
leaq 0x610c(%rip), %rdx      # 0x268b1
movb $0x0, %al
callq 0x216e0
callq 0x21530
movq %rax, %rcx
leaq 0x1b115(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x60fe(%rip), %rdx      # 0x268d1
leaq 0x6121(%rip), %r9       # 0x268fb
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
callq 0x21530
movq %rax, %rcx
leaq 0x1b0dd(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x60fd(%rip), %rdx      # 0x26909
leaq 0x60e8(%rip), %r9       # 0x268fb
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
callq 0x21530
movq %rax, %rcx
leaq 0x1b0a4(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x3, %edi
xorl %esi, %esi
leaq 0x60f1(%rip), %rdx      # 0x26936
leaq 0x60af(%rip), %r9       # 0x268fb
movl %eax, (%rsp)
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
callq 0x226c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/daemon.c
// Function: device_data_exec
static int
device_data_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;

	LOG(DEBUG, "device_data command received");

	acc_device_data(cmd_req->priv);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x21530
movq %rax, %rcx
leaq 0x1b029(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x60a9(%rip), %rdx      # 0x26962
leaq 0x60cc(%rip), %r9       # 0x2698c
movb $0x0, %al
callq 0x216e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22dd0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x21530
movq %rax, %rcx
leaq 0x1ad69(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl $0x3, %edi
xorl %esi, %esi
leaq 0x58a6(%rip), %rdx      # 0x2641f
leaq 0x58ba(%rip), %r9       # 0x2643a
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
cmpl $0xb, -0x4(%rbp)
jge 0x20bb1
movslq -0x4(%rbp), %rcx
leaq 0x21799(%rip), %rax     # 0x42338
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x20b8e
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0xb, 0x21896(%rip)     # 0x42470
jl 0x20c0c
callq 0x21530
movq %rax, %rcx
leaq 0x1ace5(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x5851(%rip), %rdx      # 0x26448
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20d01
movl $0x0, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jge 0x20cd6
movslq -0x1c(%rbp), %rcx
leaq 0x21710(%rip), %rax     # 0x42338
cmpl $-0x1, (%rax,%rcx,4)
je 0x20c33
jmp 0x20cc8
movl -0x8(%rbp), %edx
movslq -0x1c(%rbp), %rcx
leaq 0x216f7(%rip), %rax     # 0x42338
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x216e5(%rip), %rax     # 0x42338
movq %rdx, 0x30(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x216d1(%rip), %rax     # 0x42338
movq %rdx, 0x88(%rax,%rcx,8)
movl 0x217fb(%rip), %eax     # 0x42470
addl $0x1, %eax
movl %eax, 0x217f2(%rip)     # 0x42470
callq 0x21530
movq %rax, %rcx
leaq 0x1ac43(%rip), %rax     # 0x3b8d0
movq 0x18(%rax), %r8
movl -0x1c(%rbp), %r10d
movl 0x217d5(%rip), %eax     # 0x42470
movl $0x3, %edi
xorl %esi, %esi
leaq 0x57bd(%rip), %rdx      # 0x26466
leaq 0x57e1(%rip), %r9       # 0x26491
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x216e0
movl $0x0, -0x4(%rbp)
jmp 0x20d01
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20c13
callq 0x21530
movq %rax, %rcx
leaq 0x1abeb(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x57ad(%rip), %rdx      # 0x2649e
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)