LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::~Graph()
Graph::~Graph()
{
	gDataCols.clear();
	gRows.clear();
	delete this->graphTitle;
	delete this->graphMaxItem;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x872c
movq %rax, 0x68(%rbx)
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x873a
movq %rax, 0x50(%rbx)
movq 0x38(%rbx), %rdi
movl $0x30, %esi
callq 0x32d0
movq 0x40(%rbx), %rdi
movl $0x20, %esi
callq 0x32d0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x876b
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x32d0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x8781
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x32d0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::Update()
void Graph::Update()
{
	// Update the data
	for (size_t i = 0; i < this->gDataCols.size(); i++)
	{
		gDataCols[i]->Update();
	}

	this->Print();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x8cbe
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
callq 0x8188
incq %r14
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x8c9e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8cce
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::Print()
void Graph::Print()
{
	// Scan the data columns for the maximum
	int max = 0;
	for (size_t i = 0; i < this->gDataCols.size(); i++)
	{
		int tempValue = gDataCols[i]->GetValue();
		if (tempValue > max)
		{
			max = tempValue;
		}
	}

	wborder(this->win, 0, 0, 0, 0, 0, 0, 0, 0);
	wrefresh(this->win);

	// Print the graph contents
	for (size_t i = 0; i < this->gRows.size(); i++)
	{
		gRows[i]->Update(&(this->gDataCols), max);
	}

	this->graphMaxItem->UpdateMaxItem(max);

	this->graphTitle->Update();

	wrefresh(this->win);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdx
xorl %eax, %eax
movl $0x0, %r14d
subq %rcx, %rdx
je 0x8d14
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movl (%rdi), %edi
cmpl %r14d, %edi
cmovgl %edi, %r14d
incq %rsi
cmpq %rsi, %rdx
jne 0x8cff
movq (%rbx), %rdi
subq $0x8, %rsp
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x31c0
addq $0x20, %rsp
movq (%rbx), %rdi
callq 0x3310
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x8d72
leaq 0x60(%rbx), %r15
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x8410
incq %r12
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x8d4c
movq 0x40(%rbx), %rdi
movl %r14d, 0x18(%rdi)
callq 0x868c
movq 0x38(%rbx), %rdi
callq 0x8548
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::Clear()
void Graph::Clear()
{
	for (size_t i = 0; i < this->gDataCols.size(); i++)
	{
		gDataCols[i]->Clear();
	}

	for (size_t i = 0; i < this->gRows.size(); i++)
	{
		gRows[i]->Update(&(this->gDataCols), 2);
	}

	this->graphMaxItem->UpdateMaxItem(0);

	wrefresh(this->win);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
subq %rax, %rcx
je 0x8dd1
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movl $0x0, (%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x8dbf
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x8e0a
leaq 0x60(%rbx), %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x8410
incq %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x8de2
movq 0x40(%rbx), %rdi
movl $0x0, 0x18(%rdi)
callq 0x868c
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::UpdateGraphInterface(Interface*)
void Graph::UpdateGraphInterface(Interface *interface)
{
	this->interface = interface;

	this->graphTitle->UpdateGraphInterface(interface);

	for (size_t i = 0; i < this->gDataCols.size(); i++)
	{
		gDataCols[i]->UpdateGraphInterface(interface);
	}

	this->Clear();
	this->Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
movq 0x38(%rdi), %rdi
movq %rsi, 0x20(%rdi)
callq 0x8548
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x8e75
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq %r14, 0x10(%rdi)
callq 0x8188
incq %r15
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x8e51
movq %rbx, %rdi
callq 0x8d9c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8c8a
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: InterfaceHeader::PrintTabTitle(int, char*)
void InterfaceHeader::PrintTabTitle(int index, char *text)
{
	if (this->activeTab == index)
	{
		wattron(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		wprintw(this->win, "%s",
				text);
		wattroff(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		wattron(this->win, COLOR_PAIR(HEADER_COLOR));
	}
	else if (this->sortingHeader == index)
	{
		wattron(this->win, COLOR_PAIR(HEADER_SORT_COLOR));
		wprintw(this->win, "%s",
				text);
		wattroff(this->win, COLOR_PAIR(HEADER_SORT_COLOR));
		wattron(this->win, COLOR_PAIR(HEADER_COLOR));
	}
	else
	{
		wprintw(this->win, "%s",
				text);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl %esi, 0xc(%rdi)
jne 0x93f4
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leaq 0x333e(%rip), %rsi      # 0xc71e
movq %r14, %rdx
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
jmp 0x9424
movq (%rbx), %rdi
cmpl %esi, 0x8(%rbx)
jne 0x9441
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leaq 0x330c(%rip), %rsi      # 0xc71e
movq %r14, %rdx
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x33b0
movq (%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3180
leaq 0x32d6(%rip), %rsi      # 0xc71e
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: InterfaceHeader::Print()
void InterfaceHeader::Print()
{
	werase(this->win);
	wattron(this->win, COLOR_PAIR(HEADER_COLOR));
	if (this->activeTab == 0)
	{
		wattron(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		mvwprintw(this->win, 0, 1, "%*s",
				this->longest, "Interface Name");
		wattroff(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		wattron(this->win, COLOR_PAIR(HEADER_COLOR));
	}
	else
	{
		mvwprintw(this->win, 0, 1, "%*s",
				this->longest, "Interface Name");
	}
	wprintw(this->win, " | ");
	this->PrintTabTitle(1, " Rcvd Bytes  ");
	wprintw(this->win, " | ");
	this->PrintTabTitle(2, "Rcvd Pkts");
	wprintw(this->win, " | ");
	this->PrintTabTitle(3, " Sent Bytes  ");
	wprintw(this->win, " | ");
	this->PrintTabTitle(4, "Sent Pkts");
	wattroff(this->win, COLOR_PAIR(HEADER_COLOR));
	wrefresh(this->win);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3050
movq (%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x3180
cmpl $0x0, 0xc(%rbx)
movq (%rbx), %rdi
je 0x94a3
movl 0x14(%rbx), %r8d
leaq 0x3184(%rip), %rcx      # 0xc610
leaq 0x3181(%rip), %r9       # 0xc614
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x30b0
jmp 0x94f0
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
movl 0x14(%rbx), %r8d
leaq 0x3153(%rip), %rcx      # 0xc610
leaq 0x3150(%rip), %r9       # 0xc614
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x30b0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x33b0
movq (%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leaq 0x2d59(%rip), %r14      # 0xc253
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x3118(%rip), %rdx      # 0xc623
movq %rbx, %rdi
movl $0x1, %esi
callq 0x93b8
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x3105(%rip), %rdx      # 0xc631
movq %rbx, %rdi
movl $0x2, %esi
callq 0x93b8
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x30ee(%rip), %rdx      # 0xc63b
movq %rbx, %rdi
movl $0x3, %esi
callq 0x93b8
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x30db(%rip), %rdx      # 0xc649
movq %rbx, %rdi
movl $0x4, %esi
callq 0x93b8
movq (%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x33b0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: getMatchingInterface(char*)
Interface *getMatchingInterface(char *ifname)
{
	extern std::vector<Interface *> interfaces;

	for (size_t i = 0; i < interfaces.size(); ++i)
	{
		if (strcmp(interfaces[i]->name, ifname) == 0)
		{
			return interfaces[i];
		}
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x5fd0(%rip), %rax      # 0x10328
movq (%rax), %r15
movq 0x8(%rax), %r12
subq %r15, %r12
je 0xa391
movq %rdi, %rbx
sarq $0x3, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
movq (%r15,%r13,8), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x33f0
testl %eax, %eax
je 0xa394
incq %r13
cmpq %r13, %r12
jne 0xa376
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/settings.cpp
// Function: Settings::Settings()
Settings::Settings()
{
	char *homedir;
	if ((homedir = getenv("HOME")) == NULL) {
		homedir = getpwuid(getuid())->pw_dir;
	}
	const char *filename = "/.bwmon";
	strcat(homedir, filename);
	strcpy(this->settingsFileName, homedir);

	this->settingsFileExists = fileExists(this->settingsFileName);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3160
movb $0x0, 0x28(%rbx)
leaq 0x228d(%rip), %rdi      # 0xc8cb
callq 0x33a0
movq %rax, %r14
testq %rax, %rax
jne 0xa65b
callq 0x3190
movl %eax, %edi
callq 0x3350
movq 0x20(%rax), %r14
movq %r14, %rdi
callq 0x3170
movabsq $0x6e6f6d77622e2f, %rcx # imm = 0x6E6F6D77622E2F
movq %rcx, (%r14,%rax)
leaq 0x29(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3280
movq %r15, %rdi
callq 0xa455
movb %al, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa693
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3550
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/settings.cpp
// Function: Settings::Initialize()
void Settings::Initialize()
{
	if (this->settingsFileExists)
	{
		std::ifstream settingsFile(this->settingsFileName);

		// Read the file
		settingsFile >> this->root;

		settingsFile.close();
	}
	else
	{
		// Initialize the default settings locally
		this->root["sortingColumn"] = -1;
		this->root["zeroOnStart"] = 1;
		this->root["graphs"][0] = 0;
		this->root["graphs"][1] = 1;
		this->root["graphs"][2] = 2;
		this->root["graphs"][3] = 3;

		// Call save
		this->SaveSettings();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0xa741
leaq 0x29(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3570
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3590
movq %rsp, %rdi
callq 0x3090
movq %rsp, %rdi
callq 0x30c0
jmp 0xa8a3
movq %rsp, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3200
leaq 0x1b9d(%rip), %rsi      # 0xc2f2
movq %rbx, %rdi
callq 0x3130
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rsp, %rdi
movl $0x1, %esi
callq 0x3200
leaq 0x1b79(%rip), %rsi      # 0xc300
movq %rbx, %rdi
callq 0x3130
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3200
leaq 0x1b35(%rip), %rsi      # 0xc2eb
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
xorl %esi, %esi
callq 0x3300
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rsp, %rdi
movl $0x1, %esi
callq 0x3200
leaq 0x1af9(%rip), %rsi      # 0xc2eb
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
movl $0x1, %esi
callq 0x3300
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rsp, %rdi
movl $0x2, %esi
callq 0x3200
leaq 0x1aba(%rip), %rsi      # 0xc2eb
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
movl $0x2, %esi
callq 0x3300
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rsp, %rdi
movl $0x3, %esi
callq 0x3200
leaq 0x1a7b(%rip), %rsi      # 0xc2eb
movq %rbx, %rdi
callq 0x3130
movq %rax, %rdi
movl $0x3, %esi
callq 0x3300
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0xa8d8
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xa8b8
jmp 0xa8b8
jmp 0xa8b8
jmp 0xa8b8
jmp 0xa8b8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x3550
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
jmp 0xa8c3
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/settings.cpp
// Function: Settings::SaveSettings()
void Settings::SaveSettings()
{
	extern Logger *logger;

	std::ofstream settingsFile(this->settingsFileName);

	Json::StyledWriter writer;
	logger->Log(writer.write(this->root).c_str());
	settingsFile << writer.write(this->root).c_str();
	settingsFile.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %rbx
leaq 0x29(%rdi), %rsi
leaq 0x98(%rsp), %rdi
movl $0x10, %edx
callq 0x32f0
leaq 0x28(%rsp), %rdi
callq 0x3070
leaq 0x5a74(%rip), %rax      # 0x10380
movq (%rax), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0x33c0
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xa57c
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xa949
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0x33c0
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0xa982
movq %rbx, %rdi
callq 0x3170
leaq 0x98(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3320
jmp 0xa9a4
movq 0x98(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x98, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x3510
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa9bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
leaq 0x98(%rsp), %rdi
callq 0x3420
leaq 0x28(%rsp), %rdi
callq 0xaa70
movq 0x55f7(%rip), %rax      # 0xffd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0xa0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x98(%rsp,%rcx)
callq 0x3240
leaq 0x190(%rsp), %rdi
callq 0x30f0
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r14
retq
jmp 0xaa48
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0xaa39
jmp 0xaa4b
jmp 0xaa48
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0xaa4b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xaa70
leaq 0x98(%rsp), %rdi
callq 0x3430
movq %rbx, %rdi
callq 0x3550
movq %rax, %rbx
jmp 0xaa55
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/selectionWindow.cpp
// Function: SelectionWindow::Update()
void SelectionWindow::Update()
{
	werase(this->win);
	wborder(this->win, 0, 0, 0, 0, 0, 0, 0, 0);

	char graphTypeString[graphTypeStringSize];
	for (int i = 0; i < GT_END; i++)
	{
		getGraphTypeString((GraphType)i, graphTypeString);
		if (i == activeItem)
		{
			wattron(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		}
		mvwprintw(this->win, i + 1, 1, "%s", graphTypeString);
		if (i == activeItem)
		{
			wattroff(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
		}
	}

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3050
movq (%rbx), %rdi
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x31c0
addq $0x20, %rsp
movq %rsp, %r14
leaq 0x1b7e(%rip), %r15      # 0xc71e
xorl %r12d, %r12d
movl %r12d, %edi
movq %r14, %rsi
callq 0xa41b
cmpl 0x1c(%rbx), %r12d
jne 0xabc3
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leal 0x1(%r12), %ebp
movl %ebp, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x30b0
cmpl 0x1c(%rbx), %r12d
jne 0xabf4
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x33b0
movl %ebp, %r12d
cmpl $0x4, %ebp
jne 0xaba3
movq (%rbx), %rdi
callq 0x3310
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/selectionWindow.cpp
// Function: SelectionWindow::AutoResize()
void SelectionWindow::AutoResize()
{
	this->placementX = this->graph->GetPlacementX();
	this->placementY = this->graph->GetPlacementY() + 1;
	this->width = graphTypeStringSize + 1;
	this->height = (int)GT_END + 2;

	wresize(this->win, this->height, this->width);
	mvwin(this->win, this->placementY, this->placementX);

	this->Update();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x8e9c
movl %eax, 0xc(%rbx)
movq 0x20(%rbx), %rdi
callq 0x8ea0
incl %eax
movl %eax, 0x10(%rbx)
movabsq $0x600000012, %rax      # imm = 0x600000012
movq %rax, 0x14(%rbx)
movq (%rbx), %rdi
movl $0x6, %esi
movl $0x12, %edx
callq 0x31f0
movq (%rbx), %rdi
movl 0x10(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x3150
movq %rbx, %rdi
popq %rbx
jmp 0xab5e
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/footer.cpp
// Function: Footer::Print()
void Footer::Print()
{
	werase(this->win);

	char modeString[modeStringSize];
	getModeString(this->mode, modeString);
	wprintw(this->win, " Mode: %s ",
			modeString);

	wattron(this->win, COLOR_PAIR(OPTION_COLOR));
	if (this->mode == MODE_SEARCH)
	{
		wprintw(this->win, " %s | %s | %s ",
				"hl enter to Select", "q Quit", "d Deselect");
	}
	else if (this->mode == MODE_GRAPH)
	{
		wprintw(this->win, " %s | %s | %s | %s ",
				"hl enter to Select", "q Quit", "c clear", "C clear all");
	}
	else if (this->mode == MODE_GRAPH_SELECTION)
	{
		wprintw(this->win, " %s | %s ",
				"jk enter to Select", "q Quit");
	}
	else if (mode == MODE_INTERFACE_DETAIL)
	{
		wprintw(this->win, " %s | %s ",
				"jk enter to Select", "q Quit");
	}
	else if (mode == MODE_SETTINGS)
	{
		wprintw(this->win, " %s | %s ",
				"jk enter to Select", "q Quit");
	}
	else
	{
		wprintw(this->win, " %s | %s | %s | %s | %s | %s | %s | %s ",
		"jk enter to Select", "q Quit", "d Deselect", "s Sort", "S Settings", "g Graph", "z Zero", "Z Un-Zero");
	}
	wattroff(this->win, COLOR_PAIR(OPTION_COLOR));

	wrefresh(this->win);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3050
movl 0x8(%rbx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0xa3fc
movq (%rbx), %rdi
leaq 0x1b48(%rip), %rsi      # 0xc8e4
movq %r14, %rdx
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x3180
movl 0x8(%rbx), %eax
movq (%rbx), %rdi
decl %eax
cmpl $0x4, %eax
ja 0xae48
leaq 0x1b03(%rip), %rcx      # 0xc8d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b7c(%rip), %rsi      # 0xc959
leaq 0x1b44(%rip), %rdx      # 0xc928
leaq 0x1b17(%rip), %rcx      # 0xc902
xorl %eax, %eax
callq 0x3060
jmp 0xae9a
leaq 0x1b56(%rip), %rsi      # 0xc954
leaq 0x1aea(%rip), %rdx      # 0xc8ef
leaq 0x1af6(%rip), %rcx      # 0xc902
leaq 0x1af6(%rip), %r8       # 0xc909
xorl %eax, %eax
callq 0x3060
jmp 0xae9a
leaq 0x1b2c(%rip), %rsi      # 0xc94f
leaq 0x1ac5(%rip), %rdx      # 0xc8ef
leaq 0x1ad1(%rip), %rcx      # 0xc902
leaq 0x1adc(%rip), %r8       # 0xc914
leaq 0x1add(%rip), %r9       # 0xc91c
xorl %eax, %eax
callq 0x3060
jmp 0xae9a
leaq 0x1b35(%rip), %r10      # 0xc984
leaq 0x1b27(%rip), %r11      # 0xc97d
leaq 0x1b18(%rip), %r14      # 0xc975
leaq 0x1b06(%rip), %r15      # 0xc96a
leaq 0x1ad0(%rip), %rsi      # 0xc93b
leaq 0x1ab6(%rip), %rdx      # 0xc928
leaq 0x1a89(%rip), %rcx      # 0xc902
leaq 0x1a89(%rip), %r8       # 0xc909
leaq 0x1adc(%rip), %r9       # 0xc963
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r14
pushq %r15
callq 0x3060
addq $0x20, %rsp
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x33b0
movq (%rbx), %rdi
callq 0x3310
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/settingsWindow.cpp
// Function: SettingsWindow::SettingsWindow(int, int, int)
SettingsWindow::SettingsWindow(int placementX, int placementY, int width)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = SWO_END + settings->root["hiddenInterfaces"].size() + 3;

	this->max = SWO_END + settings->root["hiddenInterfaces"].size() - 1;

	this->win = newwin(this->height, this->width, this->placementY, this->placementX);

	this->Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x18(%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
leaq 0x54ae(%rip), %r15      # 0x10390
movq (%r15), %rdi
leaq 0x1292(%rip), %r14      # 0xc17e
movq %r14, %rsi
callq 0x3130
movq %rax, %rdi
callq 0x34e0
addl $0x5, %eax
movl %eax, 0x14(%rbx)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3130
movq %rax, %rdi
callq 0x34e0
incl %eax
movl %eax, 0x18(%rbx)
movl 0x14(%rbx), %edi
movl 0x10(%rbx), %esi
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
callq 0x32e0
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xaf3c
nop
// File: /workspace/github_cpp_makefile_star2_O3/Stygain[P]bandwidth-monitor/src/settingsWindow.cpp
// Function: SettingsWindow::Resize(int, int, int)
void SettingsWindow::Resize(int placementX, int placementY, int width)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = SWO_END + settings->root["hiddenInterfaces"].size() + 3;

	wresize(this->win, this->height, this->width);
	mvwin(this->win, this->placementY, this->placementX);

	this->Update();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
leaq 0x51ba(%rip), %rax      # 0x10390
movq (%rax), %rdi
leaq 0xf9e(%rip), %rsi       # 0xc17e
callq 0x3130
movq %rax, %rdi
callq 0x34e0
leal 0x5(%rax), %esi
movl %esi, 0x14(%rbx)
movq (%rbx), %rdi
movl 0x10(%rbx), %edx
callq 0x31f0
movq (%rbx), %rdi
movl 0xc(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3150
movq %rbx, %rdi
popq %rbx
jmp 0xaf3c
nop
// File: /workspace/github_cpp_makefile_star2_O3/porzell[P]PTest/examples/with_test_fixture.cpp
// Function: main
int main() {
    // Pick an individual test to run.
    bool success = PTest::PTestRegistry::Get().RunTest("MyTestFixture.FailTest");
    // Or run them all!
    return PTest::PTestRegistry::Get().RunAllTests();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x27d4
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x29da(%rip), %rsi      # 0x50a9
leaq 0x29e9(%rip), %rdx      # 0x50bf
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b0c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x26fb
callq 0x2140
callq 0x27d4
movq %rax, %rdi
callq 0x2b6c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2724
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistrar::PTestRegistrar(char const*, char const*, PTest::PTestFixture*)
PTestRegistrar(const char* testName, const char* fixtureName, PTestFixture* fixture) {
			SetConsoleColor(PColor::Blue);
			printf("Found test %s.%s...\n", fixtureName, testName);
			SetConsoleColor(PColor::Normal);
			PTestRegistry::Get().AddTest(std::move(PTest(testName, fixtureName, fixture)));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x28f6(%rip), %rdi      # 0x5043
xorl %eax, %eax
callq 0x2030
leaq 0x2965(%rip), %rdi      # 0x50c0
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2030
leaq 0x28da(%rip), %rdi      # 0x5049
xorl %eax, %eax
callq 0x2030
callq 0x27d4
movq %rax, %r12
leaq -0xa0(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3006
movq %r12, %rdi
movq %r13, %rsi
callq 0x2df2
leaq -0xa0(%rbp), %rdi
callq 0x3076
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3076
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistry::RunTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RunTest(std::string testName) {
			auto it = testMap_.find(testName);
			if (it == testMap_.end()) {
				SetConsoleColor(PColor::Red);
				printf("[TEST \"%s\" NOT FOUND!]\n", testName.c_str());
				SetConsoleColor(PColor::Normal);
				return false;
			}

			currentTest_ = &it->second;

			return it->second.Run();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x327a
testq %rax, %rax
je 0x2b37
addq $0x28, %rax
movq %rax, 0x50(%r14)
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x40ec
leaq 0x24f9(%rip), %rdi      # 0x5037
xorl %eax, %eax
callq 0x2030
movq (%rbx), %rsi
leaq 0x26f9(%rip), %rdi      # 0x5248
xorl %eax, %eax
callq 0x2030
leaq 0x24ec(%rip), %rdi      # 0x5049
xorl %eax, %eax
callq 0x2030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/main.cpp
// Function: main
int main(int argc, char **argv){
	if(argc!=2)
		fatal("Select one input file");
	
	std::ifstream in_file(argv[1]);
	std::stringstream ss;
	ss<<in_file.rdbuf();
	std::string char_stream=ss.str();
	
	lex(char_stream);
	parse();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
cmpl $0x2, %edi
jne 0x2607
movq 0x8(%rsi), %rsi
leaq -0x400(%rbp), %rdi
movl $0x8, %edx
callq 0x2290
leaq -0x1f8(%rbp), %rdi
callq 0x2110
leaq -0x1e8(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x2060
leaq -0x1e0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2230
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x26ac
leaq -0x30(%rbp), %rdi
callq 0x27e8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25b7
callq 0x2190
callq 0x42db
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25ce
callq 0x2190
movq 0x59eb(%rip), %rsi      # 0x7fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2130
leaq -0x178(%rbp), %rdi
callq 0x20a0
leaq -0x400(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x29f7(%rip), %rsi      # 0x500d
leaq 0x2a05(%rip), %rdx      # 0x5022
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x274a
movq %rbx, %rdi
callq 0x24ec
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2666
callq 0x2190
jmp 0x2666
jmp 0x2646
movq %rax, %rbx
jmp 0x2678
movq %rax, %rbx
jmp 0x2697
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x26a3
callq 0x2190
jmp 0x26a3
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2678
callq 0x2190
movq 0x5941(%rip), %rsi      # 0x7fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2130
leaq -0x178(%rbp), %rdi
callq 0x20a0
leaq -0x400(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/lex.cpp
// Function: lex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void lex(std::string stream){
	token tok="";
	for(int i=0;i<stream.length();i++){
		if(stream[i]==' ' || stream[i]=='\t' || stream[i]=='\n'){
			if(tok.length()) tokens.push_back(tok);
			tok="";
		}
		else
			tok+=stream[i];
	}
	tokens.push_back("$");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x299a(%rip), %rdx      # 0x51a5
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x274a
cmpq $0x0, 0x8(%rbx)
je 0x288e
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
movabsq $0x100000600, %r12      # imm = 0x100000600
leaq 0x296f(%rip), %r15      # 0x51a5
movq (%rbx), %rax
movzbl (%rax,%r13), %eax
cmpq $0x20, %rax
ja 0x287a
btq %rax, %r12
jae 0x287a
cmpq $0x0, -0x40(%rbp)
je 0x2866
leaq 0x5920(%rip), %rdi      # 0x8178
movq %r14, %rsi
callq 0x2976
movq -0x40(%rbp), %rdx
jmp 0x2868
xorl %edx, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x2210
jmp 0x2885
movsbl %al, %esi
movq %r14, %rdi
callq 0x2160
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x2836
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x27b0(%rip), %rsi      # 0x504d
leaq 0x27aa(%rip), %rdx      # 0x504e
leaq -0x68(%rbp), %rdi
callq 0x274a
leaq 0x58c4(%rip), %rdi      # 0x8178
leaq -0x68(%rbp), %rsi
callq 0x2bde
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x28cb
callq 0x2190
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x28dd
callq 0x2190
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x2904
callq 0x2190
jmp 0x2904
jmp 0x2901
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2916
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/parse.cpp
// Function: to_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int to_num(token t){
	int n=0;
	for(int i=0;i<t.length();i++){
		if(t[i]<'0' || t[i]>'9') return -1;
		n*=10;
		n+=t[i]-'0';
	}
	return n;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x33f3
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movzbl (%rdx,%rsi), %edi
leal -0x3a(%rdi), %r8d
cmpb $-0xa, %r8b
jb 0x33f6
leal (%rax,%rax,4), %eax
leal (%rdi,%rax,2), %eax
addl $-0x30, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x33d2
jmp 0x33fb
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/parse.cpp
// Function: keyword_to_str[abi:cxx11](Keywords_enum)
std::string keyword_to_str(Keyword k){
	switch(k){
	#define o(id, val, num) case id: return val;
		LEX_LIST
	#undef o
	default: return "INVALID KEYWORD";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %esi
cmpl $0x14, %esi
ja 0x35c8
leaq 0x1bc4(%rip), %rax      # 0x506c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1c18(%rip), %rsi      # 0x50d0
leaq 0x1c15(%rip), %rdx      # 0x50d4
jmp 0x3636
leaq 0x1c53(%rip), %rsi      # 0x511e
leaq 0x1c4f(%rip), %rdx      # 0x5121
jmp 0x3636
leaq 0x1c38(%rip), %rsi      # 0x5116
leaq 0x1c35(%rip), %rdx      # 0x511a
jmp 0x3636
leaq 0x1c12(%rip), %rsi      # 0x5103
leaq 0x1c12(%rip), %rdx      # 0x510a
jmp 0x3636
leaq 0x1bde(%rip), %rsi      # 0x50e2
leaq 0x1bda(%rip), %rdx      # 0x50e5
jmp 0x3636
leaq 0x1bf4(%rip), %rsi      # 0x510b
leaq 0x1bf3(%rip), %rdx      # 0x5111
jmp 0x3636
leaq 0x1bcd(%rip), %rsi      # 0x50f7
leaq 0x1bc9(%rip), %rdx      # 0x50fa
jmp 0x3636
leaq 0x1b9c(%rip), %rsi      # 0x50d9
leaq 0x1b99(%rip), %rdx      # 0x50dd
jmp 0x3636
leaq 0x1bcb(%rip), %rsi      # 0x511b
leaq 0x1bc6(%rip), %rdx      # 0x511d
jmp 0x3636
leaq 0x1b7b(%rip), %rsi      # 0x50de
leaq 0x1b77(%rip), %rdx      # 0x50e1
jmp 0x3636
leaq 0x1b79(%rip), %rsi      # 0x50ef
leaq 0x1b75(%rip), %rdx      # 0x50f2
jmp 0x3636
leaq 0x1b4c(%rip), %rsi      # 0x50d5
leaq 0x1b48(%rip), %rdx      # 0x50d8
jmp 0x3636
leaq 0x1b86(%rip), %rsi      # 0x5122
leaq 0x1b82(%rip), %rdx      # 0x5125
jmp 0x3636
leaq 0x1a9e(%rip), %rsi      # 0x504d
leaq 0x1a98(%rip), %rdx      # 0x504e
jmp 0x3636
leaq 0x1b27(%rip), %rsi      # 0x50e6
leaq 0x1b23(%rip), %rdx      # 0x50e9
jmp 0x3636
leaq 0x1b61(%rip), %rsi      # 0x5130
leaq 0x1b69(%rip), %rdx      # 0x513f
jmp 0x3636
leaq 0x1b33(%rip), %rsi      # 0x5112
leaq 0x1b2f(%rip), %rdx      # 0x5115
jmp 0x3636
leaq 0x1afb(%rip), %rsi      # 0x50ea
leaq 0x1af8(%rip), %rdx      # 0x50ee
jmp 0x3636
leaq 0x1b27(%rip), %rsi      # 0x5126
leaq 0x1b24(%rip), %rdx      # 0x512a
jmp 0x3636
leaq 0x1aec(%rip), %rsi      # 0x50fb
leaq 0x1aec(%rip), %rdx      # 0x5102
jmp 0x3636
leaq 0x1ad4(%rip), %rsi      # 0x50f3
leaq 0x1ad0(%rip), %rdx      # 0x50f6
jmp 0x3636
leaq 0x1afc(%rip), %rsi      # 0x512b
leaq 0x1af9(%rip), %rdx      # 0x512f
movq %rbx, %rdi
callq 0x274a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/parse.cpp
// Function: parse_stmt_list()
void parse_stmt_list(){
	token t=peek();
	if(keyword_map[t]==TOK_EOS
		|| keyword_map[t]==TOK_END) return;
	if(keyword_map[t]==TOK_END 
		|| keyword_map[t]==TOK_INT 
		|| keyword_map[t]==TOK_CHAR) 
		parse_error("Wrong token: "+t);
	else parse_stmt();
	parse_stmt_list();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movslq 0x411a(%rip), %rax      # 0x81f0
leaq 0x409b(%rip), %rcx      # 0x8178
movq (%rcx), %rcx
shlq $0x5, %rax
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x26ac
leaq 0x40ad(%rip), %rdi      # 0x81b8
movq %rbx, %rsi
callq 0x43a2
cmpl $0x15, (%rax)
je 0x4176
leaq 0x4099(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x2, (%rax)
je 0x4176
leaq 0x4084(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x2, (%rax)
je 0x418d
leaq 0x406f(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x12, (%rax)
je 0x418d
leaq 0x405a(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x13, (%rax)
je 0x418d
callq 0x38e5
callq 0x40c4
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4184
callq 0x2190
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10ea(%rip), %rsi      # 0x527e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4421
leaq -0x50(%rbp), %rdi
callq 0x2de4
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41c4
callq 0x2190
jmp 0x41c4
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x41d2
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Danis98[P]PietGen/parse.cpp
// Function: parse_prog()
void parse_prog(){
	token t=peek();
	if(keyword_map[t]==TOK_EOS) return;
	if(keyword_map[t]==TOK_END 
		|| keyword_map[t]==TOK_INT 
		|| keyword_map[t]==TOK_CHAR) 
		parse_error("Wrong token: "+t);
	else parse_stmt_list();
	
	print_ast();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movslq 0x4004(%rip), %rax      # 0x81f0
leaq 0x3f85(%rip), %rcx      # 0x8178
movq (%rcx), %rcx
shlq $0x5, %rax
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x26ac
leaq 0x3f97(%rip), %rdi      # 0x81b8
movq %rbx, %rsi
callq 0x43a2
cmpl $0x15, (%rax)
je 0x4277
leaq 0x3f83(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x2, (%rax)
je 0x428e
leaq 0x3f6e(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x12, (%rax)
je 0x428e
leaq 0x3f59(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43a2
cmpl $0x13, (%rax)
je 0x428e
callq 0x40c4
callq 0x3648
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4285
callq 0x2190
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfe9(%rip), %rsi       # 0x527e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4421
leaq -0x50(%rbp), %rdi
callq 0x2de4
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42c5
callq 0x2190
jmp 0x42c5
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x42d3
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: zalloc
void* zalloc(int size)
{
	void* p = malloc(size);
	if (!p)
	{
		printf("out of memory!\r\n");
		exit(1);
	}
	memset(p,0,size);
	return p;
}

// Assembly:
pushq %rax
movslq %edi, %rsi
movl $0x1, %edi
callq 0x21e0
testq %rax, %rax
je 0x250f
popq %rcx
retq
leaq 0xffc4(%rip), %rdi      # 0x124da
callq 0x20d0
movl $0x1, %edi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: item_remove
void item_remove(item* i)
{
	item** child;
	item* p = i->parent;
	for (child = p->child;child != p->childend;++child)
		if (*child == i)
		{
			memmove(child,child+1,(p->childend-child-1)*sizeof(item*));
			--p->childend;
			break;
		}

	i->parent = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x25af
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rbx, (%rdi)
je 0x25a1
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x258d
jmp 0x25af
leaq 0x8(%rdi), %rsi
callq 0x22c0
addq $-0x8, 0x20(%r14)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: item_add
void item_add(item* p,item* child)
{
	if (!child)
		return;

	if (child->parent)
		item_remove(child);

	if (p->childalloc == p->childend)
	{
		intptr_t count = p->childend - p->child;
		intptr_t alloc = count+16;
		p->child = (item**)realloc(p->child,sizeof(item*)*alloc);
		if (!p->child)
		{
			printf("out of memory!\r\n");
			exit(1);
		}
		p->childend = p->child+count;
		p->childalloc = p->child+alloc;
	}
	*(p->childend++) = child;
	child->parent = p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2672
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
testq %r15, %r15
je 0x2620
movq 0x18(%r15), %rdi
movq 0x20(%r15), %rax
cmpq %rax, %rdi
je 0x2618
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rbx, (%rdi)
je 0x260a
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x25f6
jmp 0x2618
leaq 0x8(%rdi), %rsi
callq 0x22c0
addq $-0x8, 0x20(%r15)
movq $0x0, 0x10(%rbx)
movq 0x20(%r14), %rax
movq 0x28(%r14), %r15
cmpq %rax, %r15
jne 0x2663
movq 0x18(%r14), %rdi
subq %rdi, %r15
movq %r15, %r12
sarq $0x3, %r12
leaq 0x80(,%r12,8), %rsi
callq 0x22a0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x267e
addq $0x10, %r12
addq %rax, %r15
leaq (%rax,%r12,8), %rax
movq %rax, 0x28(%r14)
movq %r15, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x20(%r14)
movq %rbx, (%rax)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xfe55(%rip), %rdi      # 0x124da
callq 0x20d0
movl $0x1, %edi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: item_find
item* item_find(const item* parent,const char* value)
{
	if (parent)
	{
		item** child;
		for (child = parent->child;child != parent->childend;++child)
			if (stricmp((*child)->value,value)==0)
				return *child;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x26cc
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x26cc
movq %rsi, %rbx
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2070
testl %eax, %eax
je 0x26cf
addq $0x8, %r15
cmpq %r12, %r15
jne 0x26b1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: item_get
item* item_get(item* parent,const char* value,int defined)
{
	item* p = item_find(parent,value);
	if (!p)
	{
		p = (item*)zalloc(sizeof(item));
		if (value)
			p->value = strdup(value);
		if (parent)
			item_add(parent,p);
	}
	if (defined)
		p->flags |= FLAG_DEFINED;
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
callq 0x2694
movq %rax, %r14
testq %rax, %rax
jne 0x2755
movl $0x38, %edi
callq 0x24fa
movq %rax, %r14
testq %r12, %r12
je 0x2745
movq %r12, %rdi
callq 0x2340
movq %rax, (%r14)
testq %r15, %r15
je 0x2755
movq %r15, %rdi
movq %r14, %rsi
callq 0x25bf
testl %ebx, %ebx
je 0x275e
orb $0x20, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: getvalue
item* getvalue(item* p)
{
	if (p)
	{
		item** child;
		for (child=p->child;child!=p->childend;++child)
			if (!((*child)->flags & FLAG_REMOVED))
				return *child;
	}
	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x27ab
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
je 0x27ab
movq (%rcx), %rax
testb $0x40, 0x30(%rax)
je 0x27ad
addq $0x8, %rcx
jmp 0x2797
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: setvalue
void setvalue(item* p,const char* value)
{
    item* v = getvalue(p);
    if (v)
    {
        if (strcmp(v->value,value)==0)
            return;
        v->flags |= FLAG_REMOVED;
    }
    item_get(p,value,1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x27f6
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
cmpq %rcx, %rax
je 0x27f6
movq (%rax), %r15
movl 0x30(%r15), %ebp
testb $0x40, %bpl
je 0x27e0
addq $0x8, %rax
jmp 0x27c8
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21f0
testl %eax, %eax
je 0x2810
orl $0x40, %ebp
movl %ebp, 0x30(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x270b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: compare_use
int compare_use(const item* a, const item* b)
{
	item* refa = findref(a);
	item* refb = findref(b);
	if (refa && refb)
	{
		size_t i;
		item* use;

		use = item_get(refb,"use",0);
		for (i=0;i<item_childcount(use);++i)
			if (refa == findref(use->child[i]))
			{
				use = item_get(refa,"use",0);
				for (i=0;i<item_childcount(use);++i)
					if (refb == findref(use->child[i]))
					{
						// circular reference
						return compare_name(refa,refb);
					}

				return 1;
			}

	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x281b
movq %rax, %rbx
movq %r14, %rdi
callq 0x281b
movq %rax, %r14
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x2ba2
leaq 0xe5d5(%rip), %rsi      # 0x110dc
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
testq %r15, %r15
je 0x2b2a
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2b2c
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2ba2
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x281b
incq %r12
cmpq %rax, %rbx
jne 0x2b17
leaq 0xe58f(%rip), %rsi      # 0x110dc
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
testq %r15, %r15
je 0x2b70
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2b72
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2bb0
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x281b
incq %r12
cmpq %rax, %r14
jne 0x2b5d
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2ba4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x1, %eax
jmp 0x2ba4
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: precompare_use
int precompare_use(const item* refa, const item* refb)
{
	size_t i;
	item* use;

	use = item_get((item*)refb,"use",0);
	for (i=0;i<item_childcount(use);++i)
		if (refa == findref(use->child[i]))
		{
			use = item_get((item*)refa,"use",0);
			for (i=0;i<item_childcount(use);++i)
				if (refb == findref(use->child[i]))
				{
					// circular reference
					return compare_name(refa,refb);
				}

			return 1;
		}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe510(%rip), %rsi      # 0x110dc
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
testq %r15, %r15
je 0x2bef
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2bf1
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2c67
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x281b
incq %r12
cmpq %r14, %rax
jne 0x2bdc
leaq 0xe4ca(%rip), %rsi      # 0x110dc
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
testq %r15, %r15
je 0x2c35
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2c37
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2c6b
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x281b
incq %r12
cmpq %rbx, %rax
jne 0x2c22
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2c70
xorl %eax, %eax
jmp 0x2c70
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: item_sort
void item_sort(item* p,int(*compare)(const item*, const item*))
{
	if (item_childcount(p)>=2)
	{
		int changed;
		do
		{
			size_t i,j,n=item_childcount(p);
            changed=0;

			for (i=0;i<n;++i)
                for (j=i+1;j<n;++j)
                    if (compare(p->child[i],p->child[j]))
				    {
					    item* tmp = p->child[i];
					    p->child[i] = p->child[j];
					    p->child[j] = tmp;
    				    changed=1;
                    }

		} while (changed);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2d30
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
cmpq $0x9, %rax
jb 0x2d22
movq %rsi, %rbx
movq 0x20(%r14), %r15
movq 0x18(%r14), %rax
subq %rax, %r15
je 0x2d22
sarq $0x3, %r15
cmpq $0x1, %r15
movq %r15, %rax
adcq $0x0, %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
leaq 0x1(%r13), %r12
cmpq %r15, %r12
movq %r12, 0x10(%rsp)
jae 0x2d12
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rdi
movq (%rax,%r12,8), %rsi
callq *%rbx
testl %eax, %eax
je 0x2d0a
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rcx
movq (%rax,%r12,8), %rdx
movq %rdx, (%rax,%r13,8)
movq 0x18(%r14), %rax
movq %rcx, (%rax,%r12,8)
movl $0x1, %ebp
incq %r12
cmpq %r15, %r12
jb 0x2cdb
movq 0x10(%rsp), %r13
cmpq 0x8(%rsp), %r13
jne 0x2ccd
testl %ebp, %ebp
jne 0x2ca7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: itemcond_delete
void itemcond_delete(itemcond* p)
{
	if (p && --p->refcount==0)
	{
		itemcond_delete(p->a);
		itemcond_delete(p->b);
		free(p);
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2d3e
movq %rdi, %rbx
decl (%rdi)
je 0x2d40
popq %rbx
retq
movq 0x10(%rbx), %rdi
callq 0x2d31
movq 0x18(%rbx), %rdi
callq 0x2d31
movq %rbx, %rdi
popq %rbx
jmp 0x2050