LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Engine::Crypt(std::istream&, std::ostream&, bool)
void Engine::Crypt(istream& I, ostream& O, bool unwrapFlag)
{
    if (phase != fresh)
        throw Exception("The phase must be fresh to call Engine::Crypt().");
    for(unsigned int i=0; i<Pi; i++)
        Pistons[i].Crypt(I, O, Et[i], unwrapFlag);
    if (hasMore(I))
        phase = crypted;
    else
        phase = endOfCrypt;
}

// Assembly:
subq $0x98, %rsp
movb %cl, %al
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x10(%rax)
je 0x15a56
movb $0x1, 0x43(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x20(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdce0
movq 0x28(%rsp), %rdx
leaq 0x5874(%rip), %rsi      # 0x1b241
leaq 0x58(%rsp), %rdi
callq 0xe740
jmp 0x159d9
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xde70
jmp 0x159ea
movq 0x20(%rsp), %rdi
movb $0x0, 0x43(%rsp)
movq 0xa5c5(%rip), %rsi      # 0x1ffc0
movq 0xa5b6(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x15b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x15a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xe450
leaq 0x57(%rsp), %rdi
callq 0xe050
testb $0x1, 0x43(%rsp)
jne 0x15a47
jmp 0x15a51
movq 0x20(%rsp), %rdi
callq 0xdd30
jmp 0x15b17
movl $0x0, 0x3c(%rsp)
movq 0x30(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl (%rcx), %eax
jae 0x15ae2
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe150
movq 0x30(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe3a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl (%rax), %ecx
movb 0x7f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xded0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x15a5e
movq 0x88(%rsp), %rdi
callq 0xd250
testb $0x1, %al
jne 0x15af5
jmp 0x15b03
movq 0x30(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0x15b0f
movq 0x30(%rsp), %rax
movl $0x2, 0x10(%rax)
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Engine::GetTags(std::ostream&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void Engine::GetTags(ostream& T, const vector<unsigned int>& l)
{
    if (phase != endOfMessage)
        throw Exception("The phase must be endOfMessage to call Engine::GetTags().");
    Spark(true, l);
    for(unsigned int i=0; i<Pi; i++)
        Pistons[i].GetTag(T, l[i]);
    phase = fresh;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x3, 0x10(%rax)
je 0x15e88
movb $0x1, 0x3b(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x18(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdce0
movq 0x20(%rsp), %rdx
leaq 0x54bc(%rip), %rsi      # 0x1b2bb
leaq 0x50(%rsp), %rdi
callq 0xe740
jmp 0x15e0b
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xde70
jmp 0x15e1c
movq 0x18(%rsp), %rdi
movb $0x0, 0x3b(%rsp)
movq 0xa193(%rip), %rsi      # 0x1ffc0
movq 0xa184(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x15f20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x15e66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xe450
leaq 0x4f(%rsp), %rdi
callq 0xe050
testb $0x1, 0x3b(%rsp)
jne 0x15e79
jmp 0x15e83
movq 0x18(%rsp), %rdi
callq 0xdd30
jmp 0x15f16
movq 0x28(%rsp), %rdi
movq 0x70(%rsp), %rdx
movl $0x1, %esi
callq 0xdd70
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl (%rcx), %eax
jae 0x15f02
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0xe150
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0xd930
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl (%rax), %edx
callq 0xe760
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x15ea4
movq 0x28(%rsp), %rax
movl $0x0, 0x10(%rax)
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xe7c0
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Motorist::StartEngine(std::istream&, bool, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, bool, bool)
bool Motorist::StartEngine(istream& SUV, bool tagFlag, stringstream& T, bool unwrapFlag, bool forgetFlag)
{
    if (phase != ready)
        throw Exception("The phase must be ready to call Motorist::StartEngine().");
    engine.InjectCollective(SUV, true);
    if (forgetFlag)
        MakeKnot();
    bool res = HandleTag(tagFlag, T, unwrapFlag);
    if (res)
        phase = riding;
    return res;
}

// Assembly:
subq $0x98, %rsp
movl %r8d, 0x14(%rsp)
movq %rcx, %rax
movl 0x14(%rsp), %ecx
movq %rax, 0x18(%rsp)
movl %edx, %eax
movq 0x18(%rsp), %rdx
movl %eax, 0x24(%rsp)
movq %rsi, %rax
movl 0x24(%rsp), %esi
movq %rax, 0x28(%rsp)
movq %rdi, %r8
movq 0x28(%rsp), %rdi
movb %r9b, %al
movq %r8, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
andb $0x1, %sil
movb %sil, 0x87(%rsp)
movq %rdx, 0x78(%rsp)
andb $0x1, %cl
movb %cl, 0x77(%rsp)
andb $0x1, %al
movb %al, 0x76(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x60(%rax)
je 0x16910
movb $0x1, 0x3b(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, (%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdce0
movq 0x8(%rsp), %rdx
leaq 0x4aaf(%rip), %rsi      # 0x1b33c
leaq 0x50(%rsp), %rdi
callq 0xe740
jmp 0x16899
movq (%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xde70
jmp 0x168a9
movq (%rsp), %rdi
movb $0x0, 0x3b(%rsp)
movq 0x9707(%rip), %rsi      # 0x1ffc0
movq 0x96f8(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x16992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x168f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xe450
leaq 0x4f(%rsp), %rdi
callq 0xe050
testb $0x1, 0x3b(%rsp)
jne 0x16905
jmp 0x1690e
movq (%rsp), %rdi
callq 0xdd30
jmp 0x16988
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x88(%rsp), %rsi
movl $0x1, %edx
callq 0xe560
testb $0x1, 0x76(%rsp)
je 0x1693c
movq 0x30(%rsp), %rdi
callq 0xe4c0
movq 0x30(%rsp), %rdi
movb 0x87(%rsp), %cl
movq 0x78(%rsp), %rdx
movb 0x77(%rsp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %ecx
callq 0xdcc0
andb $0x1, %al
movb %al, 0x3a(%rsp)
testb $0x1, 0x3a(%rsp)
je 0x1697a
movq 0x30(%rsp), %rax
movl $0x1, 0x60(%rax)
movb 0x3a(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Motorist::MakeKnot()
void Motorist::MakeKnot()
{
    stringstream Tprime;
    engine.GetTags(Tprime, vector<unsigned int>(Pi, cprime/8));
    Tprime.seekg(0, ios_base::beg);
    engine.InjectCollective(Tprime, false);
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0xea00
movq (%rsp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x68(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl (%rax), %ecx
movl 0x58(%rax), %eax
movq %rcx, 0x18(%rsp)
shrl $0x3, %eax
movl %eax, 0x3c(%rsp)
leaq 0x3b(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdc10
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rdx
callq 0xde50
jmp 0x16a1a
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xdf00
jmp 0x16a30
leaq 0x40(%rsp), %rdi
callq 0xeaf0
leaq 0x3b(%rsp), %rdi
callq 0xe160
xorl %edx, %edx
movl %edx, %esi
leaq 0x58(%rsp), %rdi
callq 0xd4c0
jmp 0x16a54
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0xe560
jmp 0x16a6a
leaq 0x58(%rsp), %rdi
callq 0xea90
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x16aa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xeaf0
leaq 0x3b(%rsp), %rdi
callq 0xe160
jmp 0x16abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xea90
movq 0x30(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/config_app.c
// Function: uio_get_bar0_mapping
static void *
uio_get_bar0_mapping(const char *pci_addr,
		unsigned int bar_size, void *dev)
{
	char bar0path[PATH_MAX];
	int bar0addrfd;
	void *map;

	snprintf(bar0path, sizeof(bar0path),
			"%s/%s/%s", SYS_DIR, pci_addr, BAR0_FILE);
	bar0addrfd = open(bar0path, O_RDWR | O_SYNC);
	if (bar0addrfd < 0) {
		LOG(ERR, "Failed to open BAR %s", bar0path);
		exit(1);
	}
	map = mmap(0, bar_size, PROT_READ | PROT_WRITE, MAP_SHARED,
			bar0addrfd, 0);
	close(bar0addrfd);
	if (map == MAP_FAILED) {
		printf("ERR:SYSFS: mmap failed\n");
		map = NULL; /* MAP_FAILED is not equal to NULL */
	}
	return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0x15730(%rip), %rdx     # 0x2330d
leaq 0x15732(%rip), %rcx     # 0x23316
leaq 0x15740(%rip), %r9      # 0x2332b
movb $0x0, %al
callq 0xd160
leaq -0x1020(%rbp), %rdi
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0xd300
movl %eax, -0x1024(%rbp)
cmpl $0x0, -0x1024(%rbp)
jge 0xdc49
callq 0xe9a0
movq %rax, %rcx
leaq 0x2dcad(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
leaq -0x1020(%rbp), %r9
xorl %esi, %esi
leaq 0x156ff(%rip), %rdx     # 0x23335
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0x1, %edi
callq 0xd3f0
movl -0xc(%rbp), %eax
movl %eax, %esi
movl -0x1024(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0xd100
movq %rax, -0x1030(%rbp)
movl -0x1024(%rbp), %edi
callq 0xd190
movq $-0x1, %rax
cmpq %rax, -0x1030(%rbp)
jne 0xdca7
leaq 0x156bd(%rip), %rdi     # 0x23352
movb $0x0, %al
callq 0xd140
movq $0x0, -0x1030(%rbp)
movq -0x1030(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/config_app.c
// Function: bbdev_parse_args
static int
bbdev_parse_args(int argc, char **argv,
		struct hw_device *device)
{
	int opt;
	char *prgname = argv[0];
	if (argc == 1) {
		print_helper(prgname);
		return 1;
	}
	device->device_name = argv[1];

	while ((opt = getopt(argc, argv, "c:p:v:f:h")) != -1) {
		switch (opt) {
		case 'c':
			device->config_file = optarg;
			break;

		case 'p':
			strncpy(device->pci_address, optarg,
					sizeof(device->pci_address) - NULL_PAD);
			device->pci_address[PCI_STR_SIZE - 1] = 0;
			break;

		case 'v':
			device->vfio_mode = 1;
			if (vfio_uuid_parse(optarg, device->vfio_vf_token) < 0)
				return 1;
			break;

		case 'f':
			device->fft_lut_filename = optarg;
			break;

		case 'h':
		default:
			print_helper(prgname);
			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 -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xdfb9
movq -0x28(%rbp), %rdi
callq 0xe5d0
movl $0x1, -0x4(%rbp)
jmp 0xe0b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x15394(%rip), %rdx     # 0x2336a
callq 0xd370
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0xe0b2
movl -0x1c(%rbp), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x13, %eax
ja 0xe09b
movq -0x30(%rbp), %rax
leaq 0x14ffd(%rip), %rcx     # 0x23004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x2bfc9(%rip), %rax     # 0x39fe0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe0ad
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq 0x2bfaa(%rip), %rax     # 0x39fe0
movq (%rax), %rsi
movl $0xd, %edx
callq 0xd080
movq -0x18(%rbp), %rax
movb $0x0, 0x2e(%rax)
jmp 0xe0ad
movq -0x18(%rbp), %rax
movl $0x1, 0xbc(%rax)
movq 0x2bf7e(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0xdc, %rsi
callq 0x1f450
cmpl $0x0, %eax
jge 0xe083
movl $0x1, -0x4(%rbp)
jmp 0xe0b9
jmp 0xe0ad
movq 0x2bf54(%rip), %rax     # 0x39fe0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xe0ad
jmp 0xe09b
movq -0x28(%rbp), %rdi
callq 0xe5d0
movl $0x1, -0x4(%rbp)
jmp 0xe0b9
jmp 0xdfc8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/config_app.c
// Function: select_device
static int
select_device(hw_device *device, char **found_devices, int num_devices)
{
	int i, selected, ret;
	/* If more than one device found, get user input on which to use */
	if (num_devices >= 2) {
		printf("More than one device found. Please select which device you would like to use from the list:\n");

		/*Print PCI Slots */
		for (i = 0; i < num_devices; i++)
			printf("[%i]: %s\n", i+1, found_devices[i]);

		printf("> ");
		ret = scanf("%d", &selected);
		if (selected >= 1 && selected <= num_devices && ret == 1) {
			strncpy(device->pci_address, found_devices[selected-1],
					sizeof(device->pci_address) - NULL_PAD);
			return 0;
		}

		printf("Invalid Option, please try again..\n");
		return -1;
	}

	strncpy(device->pci_address, found_devices[0],
			sizeof(device->pci_address) - NULL_PAD);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jl 0xe38f
leaq 0x152d0(%rip), %rdi     # 0x235a4
movb $0x0, %al
callq 0xd140
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe315
movl -0x20(%rbp), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x152fe(%rip), %rdi     # 0x23601
movb $0x0, %al
callq 0xd140
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe2e2
leaq 0x152ef(%rip), %rdi     # 0x2360b
movb $0x0, %al
callq 0xd140
leaq 0x15f2c(%rip), %rdi     # 0x24256
leaq -0x24(%rbp), %rsi
movb $0x0, %al
callq 0xd3b0
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0xe378
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0xe378
cmpl $0x1, -0x28(%rbp)
jne 0xe378
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movl $0xd, %edx
callq 0xd080
movl $0x0, -0x4(%rbp)
jmp 0xe3af
leaq 0x1528f(%rip), %rdi     # 0x2360e
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe3af
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0xd, %edx
callq 0xd080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/config_app.c
// Function: get_file_val
static unsigned long
get_file_val(const char *file_path)
{
	char content[BUFSIZ];
	FILE *f;

	f = fopen(file_path, "r");
	if (NULL == f) {
		LOG(ERR, "Failed to open %s", file_path);
		exit(1);
	}
	if (fgets(content, sizeof(content), f) == NULL) {
		fclose(f);
		return false;
	}
	fclose(f);
	const unsigned long content_val = strtoul(content, NULL, 16);

	return content_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x158b2(%rip), %rsi     # 0x2418c
callq 0xd330
movq %rax, -0x2018(%rbp)
xorl %eax, %eax
cmpq -0x2018(%rbp), %rax
jne 0xe923
callq 0xe9a0
movq %rax, %rcx
leaq 0x2cfd0(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x10(%rbp), %r9
xorl %esi, %esi
leaq 0x14c7b(%rip), %rdx     # 0x2358b
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0x1, %edi
callq 0xd3f0
leaq -0x2010(%rbp), %rdi
movq -0x2018(%rbp), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0xd1d0
cmpq $0x0, %rax
jne 0xe957
movq -0x2018(%rbp), %rdi
callq 0xd0d0
movq $0x0, -0x8(%rbp)
jmp 0xe98a
movq -0x2018(%rbp), %rdi
callq 0xd0d0
leaq -0x2010(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0xd3a0
movq %rax, -0x2020(%rbp)
movq -0x2020(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/./bb_acc_log.h
// Function: timestamp
static char *timestamp()
{
	char *time_s;
	time_t now = time(NULL);
	const struct tm *gtm = gmtime(&now);
	if (gtm == NULL)
		return NULL;

	time_s = asctime(gtm);
	if (time_s == NULL)
		return NULL;

	time_s[strlen(time_s)-1] = '\0';
	return time_s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0xd250
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xd360
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe9d3
movq $0x0, -0x8(%rbp)
jmp 0xea19
movq -0x20(%rbp), %rdi
callq 0xd110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe9f1
movq $0x0, -0x8(%rbp)
jmp 0xea19
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: accFromQgid
int
accFromQgid(int qg_idx, struct acc100_conf *acc100_conf)
{
	int accQg[ACC100_NUM_QGRPS];
	int NumQGroupsPerFn[NUM_ACC];
	int acc, qgIdx, qgIndex = 0;
	for (qgIdx = 0; qgIdx < ACC100_NUM_QGRPS; qgIdx++)
		accQg[qgIdx] = 0;
	NumQGroupsPerFn[UL_4G] = acc100_conf->q_ul_4g.num_qgroups;
	NumQGroupsPerFn[UL_5G] = acc100_conf->q_ul_5g.num_qgroups;
	NumQGroupsPerFn[DL_4G] = acc100_conf->q_dl_4g.num_qgroups;
	NumQGroupsPerFn[DL_5G] = acc100_conf->q_dl_5g.num_qgroups;
	for (acc = UL_4G;  acc < NUM_ACC; acc++)
		for (qgIdx = 0; qgIdx < NumQGroupsPerFn[acc]; qgIdx++)
			accQg[qgIndex++] = acc;
	acc = accQg[qg_idx];
	return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
cmpl $0x8, -0x48(%rbp)
jge 0xea66
movslq -0x48(%rbp), %rax
movl $0x0, -0x30(%rbp,%rax,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xea49
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0xeadf
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movslq -0x44(%rbp), %rcx
cmpl -0x40(%rbp,%rcx,4), %eax
jge 0xead2
movl -0x44(%rbp), %ecx
movl -0x4c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x4c(%rbp)
cltq
movl %ecx, -0x30(%rbp,%rax,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xeaa6
jmp 0xead4
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xea99
movslq -0x4(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: qtopFromAcc
void
qtopFromAcc(struct q_topology_t **qtop, int acc_enum,
		struct acc100_conf *acc100_conf)
{
	struct q_topology_t *p_qtop;
	p_qtop = NULL;
	switch (acc_enum) {
	case UL_4G:
		p_qtop = &(acc100_conf->q_ul_4g);
		break;
	case UL_5G:
		p_qtop = &(acc100_conf->q_ul_5g);
		break;
	case DL_4G:
		p_qtop = &(acc100_conf->q_dl_4g);
		break;
	case DL_5G:
		p_qtop = &(acc100_conf->q_dl_5g);
		break;
	default:
		/* NOTREACHED */
		LOG(ERR, "Unexpected error evaluating qtopFromAcc");
		break;
	}
	*qtop = p_qtop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0xeb64
movq -0x28(%rbp), %rax
leaq 0x14bc5(%rip), %rcx     # 0x236e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x20(%rbp)
jmp 0xeb88
movq -0x18(%rbp), %rax
addq $0x12, %rax
movq %rax, -0x20(%rbp)
jmp 0xeb88
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
jmp 0xeb88
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0xeb88
callq 0x10830
movq %rax, %rcx
leaq 0x2cd5d(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14b79(%rip), %rdx     # 0x236f8
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: aqDepth
int
aqDepth(int qg_idx, struct acc100_conf *acc100_conf)
{
	struct q_topology_t *q_top = NULL;
	int acc_enum = accFromQgid(qg_idx, acc100_conf);
	qtopFromAcc(&q_top, acc_enum, acc100_conf);
	if (q_top == NULL)
		return 1;
	return MAX(1, q_top->aq_depth_log2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xea30
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xeaf0
cmpq $0x0, -0x18(%rbp)
jne 0xebe6
movl $0x1, -0x4(%rbp)
jmp 0xec12
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jl 0xec01
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xec0c
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -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/acc100/acc100_cfg_app.c
// Function: aqNum
int
aqNum(int qg_idx, struct acc100_conf *acc100_conf)
{
	struct q_topology_t *q_top = NULL;
	int acc_enum = accFromQgid(qg_idx, acc100_conf);
	qtopFromAcc(&q_top, acc_enum, acc100_conf);
	if (q_top == NULL)
		return 0;
	return q_top->num_aqs_per_groups;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xea30
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xeaf0
cmpq $0x0, -0x18(%rbp)
jne 0xec66
movl $0x0, -0x4(%rbp)
jmp 0xec71
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -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/acc100/acc100_cfg_app.c
// Function: acc100_configure
int
acc100_configure(void *dev, void *bar0addr, const char *cfg_filename, const bool first_cfg)
{
	struct acc100_conf acc100_conf;
	int ret;

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp            # imm = 0x350
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 -0x344(%rbp), %rsi
callq 0xed70
movl %eax, -0x348(%rbp)
cmpl $0x0, -0x348(%rbp)
je 0xecea
callq 0x10830
movq %rax, %rcx
leaq 0x2cc04(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14a4f(%rip), %rdx     # 0x23727
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x344(%rbp), %rdx
callq 0xedf0
movl %eax, -0x348(%rbp)
cmpl $0x0, -0x348(%rbp)
je 0xed3a
callq 0x10830
movq %rax, %rcx
leaq 0x2cbb4(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
xorl %esi, %esi
leaq 0x14a20(%rip), %rdx     # 0x23748
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed60
movq -0x10(%rbp), %rax
movq %rax, -0x350(%rbp)
movzwl -0x340(%rbp), %ecx
movq -0x350(%rbp), %rax
movl %ecx, 0x4f8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x350, %rsp            # imm = 0x350
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: acc100_read_config_file
static int
acc100_read_config_file(const char *arg_cfg_filename,
		struct acc100_conf *acc100_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 acc100_parse_conf_file(arg_cfg_filename, acc100_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 0xedcc
callq 0x10830
movq %rax, %rcx
leaq 0x2cb26(%rip), %rax     # 0x3b8d0
movq (%rax), %r8
movq -0x10(%rbp), %r9
xorl %esi, %esi
leaq 0x14ab9(%rip), %rdx     # 0x23873
movl %esi, %edi
movb $0x0, %al
callq 0x216e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeddc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10b60
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/acc100/acc100_cfg_parser.c
// Function: acc100_queue_range_check
int
acc100_queue_range_check(struct q_topology_t q_conf)
{
	if ((q_conf.num_aqs_per_groups < 1) ||
			(q_conf.num_aqs_per_groups > ACC100_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 > ACC100_MAX_QDEPTH)) {
		printf("ERROR: AQ Depth out of range %d\n",
				q_conf.aq_depth_log2);
		return -1;
	}
	if (q_conf.num_qgroups > ACC100_NUM_QGRPS) {
		printf("ERROR: Number of QG out of range %d\n",
				q_conf.num_qgroups);
		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 0x1095a
movzwl -0x8(%rbp), %eax
cmpl $0x10, %eax
jle 0x10975
movzwl -0x8(%rbp), %esi
leaq 0x1321b(%rip), %rdi     # 0x23b80
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x109cd
movzwl -0x6(%rbp), %eax
cmpl $0x1, %eax
jl 0x10987
movzwl -0x6(%rbp), %eax
cmpl $0xc, %eax
jle 0x109a2
movzwl -0x6(%rbp), %esi
leaq 0x13214(%rip), %rdi     # 0x23ba6
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x109cd
movzwl -0xa(%rbp), %eax
cmpl $0x8, %eax
jle 0x109c6
movzwl -0xa(%rbp), %esi
leaq 0x13211(%rip), %rdi     # 0x23bc7
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x109cd
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/acc100/acc100_cfg_parser.c
// Function: acc100_range_check
int
acc100_range_check(struct acc100_conf *acc100_conf)
{
	uint16_t totalQgs = acc100_conf->q_ul_4g.num_qgroups +
			acc100_conf->q_ul_5g.num_qgroups +
			acc100_conf->q_dl_4g.num_qgroups +
			acc100_conf->q_dl_5g.num_qgroups;
	if (totalQgs > ACC100_NUM_QGRPS) {
		printf("ERROR: Number of Qgroups %d > %d\n",
				totalQgs, ACC100_NUM_QGRPS);
		return -1;
	}
	if (acc100_conf->num_vf_bundles > ACC100_NUM_VFS) {
		printf("ERROR: Number of VFs bundle %d > %d\n",
				acc100_conf->num_vf_bundles, ACC100_NUM_VFS);
		return -1;
	}

	if (acc100_queue_range_check(acc100_conf->q_ul_4g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_dl_4g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_ul_5g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_dl_5g) != 0)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x8, %eax
jle 0x10a42
movzwl -0x12(%rbp), %esi
leaq 0x131c2(%rip), %rdi     # 0x23bec
movl $0x8, %edx
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x10, %eax
jle 0x10a76
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %esi
leaq 0x131b0(%rip), %rdi     # 0x23c0e
movl $0x10, %edx
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
movq -0x10(%rbp), %rax
movw 0xa(%rax), %cx
movw %cx, -0x1c(%rbp)
movl 0x6(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
movl %ecx, %edi
shlq $0x20, %rax
orq %rax, %rdi
callq 0x10930
cmpl $0x0, %eax
je 0x10aad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
movq -0x10(%rbp), %rax
movw 0x10(%rax), %cx
movw %cx, -0x24(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %eax
movl %ecx, %edi
shlq $0x20, %rax
orq %rax, %rdi
callq 0x10930
cmpl $0x0, %eax
je 0x10ae1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
movq -0x10(%rbp), %rax
movw 0x16(%rax), %cx
movw %cx, -0x2c(%rbp)
movl 0x12(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %eax
movl %ecx, %edi
shlq $0x20, %rax
orq %rax, %rdi
callq 0x10930
cmpl $0x0, %eax
je 0x10b15
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
movq -0x10(%rbp), %rax
movw 0x1c(%rax), %cx
movw %cx, -0x34(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %eax
movl %ecx, %edi
shlq $0x20, %rax
orq %rax, %rdi
callq 0x10930
cmpl $0x0, %eax
je 0x10b49
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10b50
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/acc100/acc100_cfg_parser.c
// Function: acc100_parse_conf_file
int
acc100_parse_conf_file(const char *file_name, struct acc100_conf *acc100_conf)
{
	int ret;

	set_default_config(acc100_conf);

	ret = cfg_parse(file_name, acc100_handler, acc100_conf);

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

	ret = acc100_range_check(acc100_conf);
	if (ret != 0) {
		printf("ERROR: Parameter out of range\n");
		set_default_config(acc100_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 0x10c00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2b8(%rip), %rsi       # 0x10e40
callq 0x17f40
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x10bb6
leaq 0x13096(%rip), %rdi     # 0x23c33
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x10c00
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10bef
movq -0x18(%rbp), %rdi
callq 0x109e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x10be8
leaq 0x13085(%rip), %rdi     # 0x23c54
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x10c00
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10bef
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/acc100/acc100_cfg_parser.c
// Function: parse_number16
static int
parse_number16(const char *str, uint16_t *value)
{
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	val = strtoul(str, &end, 0);
	if (val > UINT16_MAX || str == end) {
		printf("ERROR: Invalid value %" PRIu64 "\n", val);
		return -ERANGE;
	}

	*value = (uint16_t) val;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x118f8
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x1194f
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xd3a0
movq %rax, -0x20(%rbp)
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
ja 0x1191f
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1193a
movq -0x20(%rbp), %rsi
leaq 0x124a9(%rip), %rdi     # 0x23dd3
movb $0x0, %al
callq 0xd140
movl $0xffffffde, -0x4(%rbp) # imm = 0xFFFFFFDE
jmp 0x1194f
movq -0x20(%rbp), %rax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: parse_item_no
static int
parse_item_no(const char *full_name, const char *base_name)
{
	int postfix_len, number_start, ret;
	uint16_t item_no = 0;

	postfix_len = strlen(full_name) - strlen(base_name);
	if (postfix_len > 0) {
		number_start = strlen((const char *) base_name);
		ret = parse_number16(&full_name[number_start], &item_no);
		if (ret != 1)
			printf("ERROR: Parsing item (%d) failed (%d)\n", item_no, ret);
	}

	return item_no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x0, -0x1e(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd0f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x119df
movq -0x10(%rbp), %rdi
callq 0xd0f0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
leaq -0x1e(%rbp), %rsi
callq 0x118d0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x119dd
movzwl -0x1e(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq 0x12417(%rip), %rdi     # 0x23ded
movb $0x0, %al
callq 0xd140
jmp 0x119df
movzwl -0x1e(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: parse_number32
static int
parse_number32(const char *str, uint32_t *value)
{
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	val = strtoul(str, &end, 0);
	if (val > UINT32_MAX || str == end) {
		printf("ERROR: Invalid value %" PRIu64 "\n", val);
		return -ERANGE;
	}
	*value = (uint32_t) val;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11a18
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x11a6e
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xd3a0
movq %rax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
ja 0x11a40
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x11a5b
movq -0x20(%rbp), %rsi
leaq 0x12388(%rip), %rdi     # 0x23dd3
movb $0x0, %al
callq 0xd140
movl $0xffffffde, -0x4(%rbp) # imm = 0xFFFFFFDE
jmp 0x11a6e
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -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/fpga_lte/fpga_lte_cfg_app.c
// Function: fpga_lte_configure
int
fpga_lte_configure(void *dev, void *bar0addr, const char *cfg_filename, const bool first_cfg)
{
	struct fpga_lte_fec_conf fpga_conf;
	int ret;

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

	ret = fpga_write_config(dev, bar0addr, &fpga_conf);
	if (ret != 0) {
		printf("Error writing configuration for FPGA.\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 -0x3a(%rbp), %rsi
callq 0x11b10
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x11ac8
leaq 0x13568(%rip), %rdi     # 0x25020
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x3a(%rbp), %rdx
callq 0x11b70
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x11af9
leaq 0x12337(%rip), %rdi     # 0x23e20
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b00
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/fpga_lte/fpga_lte_cfg_app.c
// Function: fpga_read_config_file
static int
fpga_read_config_file(const char *arg_cfg_filename,
		struct fpga_lte_fec_conf *fpga_lte_fec_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 fpga_lte_parse_conf_file(arg_cfg_filename,
				fpga_lte_fec_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 0x11b56
movq -0x10(%rbp), %rsi
leaq 0x12301(%rip), %rdi     # 0x23e47
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11b66
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12230
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/fpga_lte/fpga_lte_cfg_parser.c
// Function: fpga_lte_parse_conf_file
int
fpga_lte_parse_conf_file(const char *file_name,
		struct fpga_lte_fec_conf *fpga_conf)
{
	int ret;

	set_default_config(fpga_conf);

	ret = cfg_parse(file_name, fpga_handler, fpga_conf);

	if (ret == -1) {
		printf("ERROR: Error loading configuration file %s\n",
			file_name);
		set_default_config(fpga_conf);
		return -ENOENT;
	} else if (ret == -2) {
		printf("ERROR: Memory allocation error\n");
		set_default_config(fpga_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 0x122d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xe8(%rip), %rsi        # 0x12340
callq 0x17f40
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1228a
movq -0x10(%rbp), %rsi
leaq 0x11e03(%rip), %rdi     # 0x24074
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x122d0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x122b9
cmpl $-0x2, -0x1c(%rbp)
jne 0x122b0
leaq 0x11e09(%rip), %rdi     # 0x240a0
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x122d0
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x122b9
jmp 0x122b2
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/fpga_lte/fpga_lte_cfg_parser.c
// Function: set_default_config
static void
set_default_config(struct fpga_lte_fec_conf *fpga_conf)
{
	int i;

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

	/* Set ratio between UL and DL to 1:1 (unit of weight is 3 CBs) */
	fpga_conf->ul_bandwidth = DEFAULT_UL_BANDWIDTH;
	fpga_conf->dl_bandwidth = DEFAULT_DL_BANDWIDTH;

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

	for (i = 0; i < FPGA_LTE_FEC_NUM_VFS; i++) {
		fpga_conf->vf_ul_queues_number[i] = DEFAULT_NUM_VF_QUEUE/2;
		fpga_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 $0x3, 0x11(%rax)
movq -0x8(%rbp), %rax
movb $0x3, 0x12(%rax)
movq -0x8(%rbp), %rax
movb $0x40, 0x13(%rax)
movq -0x8(%rbp), %rax
movb $0x40, 0x14(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x12331
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 0x12306
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/fpga_lte/fpga_lte_cfg_parser.c
// Function: parse_number8
static int
parse_number8(const char *str, uint8_t *value)
{
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	val = strtoul(str, &end, 0);
	if (val > UINT8_MAX || str == end) {
		printf("ERROR: Invalid value %" PRIu64 "\n", val);
		return -ERANGE;
	}

	*value = (uint8_t) val;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12628
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x1267d
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xd3a0
movq %rax, -0x20(%rbp)
cmpq $0xff, -0x20(%rbp)
ja 0x1264f
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1266a
movq -0x20(%rbp), %rsi
leaq 0x11779(%rip), %rdi     # 0x23dd3
movb $0x0, %al
callq 0xd140
movl $0xffffffde, -0x4(%rbp) # imm = 0xFFFFFFDE
jmp 0x1267d
movq -0x20(%rbp), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/fpga_lte/fpga_lte_cfg_parser.c
// Function: parse_array8
static int
parse_array8(const char *str, uint8_t *array)
{
	int i;
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	char *val_ch = strtok((char *)str, ",");
	for (i = 0; i < 8 && NULL != val_ch; i++) {

		val = strtoul(val_ch, &end, 0);
		if (val > UINT8_MAX || val_ch == end) {
			printf("ERROR: Invalid value %" PRIu64 "\n", val);
			return -ERANGE;
		}
		array[i] = (uint8_t) val;

		val_ch = strtok(NULL, ",");
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x126bb
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x12772
movq -0x10(%rbp), %rdi
leaq 0x11a82(%rip), %rsi     # 0x24148
callq 0xd350
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x8, -0x1c(%rbp)
movb %al, -0x39(%rbp)
jge 0x126ed
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x126f6
jmp 0x1276b
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0xd3a0
movq %rax, -0x28(%rbp)
cmpq $0xff, -0x28(%rbp)
ja 0x1271d
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x12738
movq -0x28(%rbp), %rsi
leaq 0x116ab(%rip), %rdi     # 0x23dd3
movb $0x0, %al
callq 0xd140
movl $0xffffffde, -0x4(%rbp) # imm = 0xFFFFFFDE
jmp 0x12772
movq -0x28(%rbp), %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
movl %eax, %edi
leaq 0x119f4(%rip), %rsi     # 0x24148
callq 0xd350
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x126d6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/intel[P]pf-bb-config/fpga_5gnr/fpga_5gnr_cfg_app.c
// Function: fpga_5gnr_configure
int
fpga_5gnr_configure(void *dev, void *bar0addr, const char *cfg_filename, const bool first_cfg)
{
	struct fpga_5gnr_fec_conf fpga_conf;
	int ret;

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

	ret = fpga_write_config(dev, bar0addr, &fpga_conf);
	if (ret != 0) {
		printf("Error writing configuration for FPGA.\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 -0x36(%rbp), %rsi
callq 0x128a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x12858
leaq 0x127d8(%rip), %rdi     # 0x25020
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12890
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x36(%rbp), %rdx
callq 0x12900
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x12889
leaq 0x115a7(%rip), %rdi     # 0x23e20
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12890
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/fpga_5gnr/fpga_5gnr_cfg_app.c
// Function: fpga_read_config_file
static int
fpga_read_config_file(const char *arg_cfg_filename,
		struct fpga_5gnr_fec_conf *fpga_5gnr_fec_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 fpga_5gnr_parse_conf_file(arg_cfg_filename,
				fpga_5gnr_fec_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 0x128e6
movq -0x10(%rbp), %rsi
leaq 0x11571(%rip), %rdi     # 0x23e47
movb $0x0, %al
callq 0xd140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x128f6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12f70
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/fpga_5gnr/fpga_5gnr_cfg_parser.c
// Function: fpga_5gnr_parse_conf_file
int
fpga_5gnr_parse_conf_file(const char *file_name,
		struct fpga_5gnr_fec_conf *fpga_conf)
{
	int ret;

	set_default_config(fpga_conf);

	ret = cfg_parse(file_name, fpga_handler, fpga_conf);

	if (ret == -1) {
		printf("ERROR: Error loading configuration file %s\n",
			file_name);
		set_default_config(fpga_conf);
		return -ENOENT;
	} else if (ret == -2) {
		printf("ERROR: Memory allocation error\n");
		set_default_config(fpga_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 0x13010
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xe8(%rip), %rsi        # 0x13080
callq 0x17f40
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x12fca
movq -0x10(%rbp), %rsi
leaq 0x110c3(%rip), %rdi     # 0x24074
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x13010
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x12ff9
cmpl $-0x2, -0x1c(%rbp)
jne 0x12ff0
leaq 0x110c9(%rip), %rdi     # 0x240a0
movb $0x0, %al
callq 0xd140
movq -0x18(%rbp), %rdi
callq 0x13010
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x12ff9
jmp 0x12ff2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)