LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphRow::Update(std::vector<GraphDataColumn*, std::allocator<GraphDataColumn*>>*, int)
void GraphRow::Update(std::vector<GraphDataColumn *> *gDataCols, int max)
{
	werase(this->win);
	float currPos = (float)this->value / (float)this->max;
	for (size_t i = 0; i < gDataCols->size(); i++)
	{
		float valuePercent = (float)gDataCols->at(i)->GetValue() / (float)max;
		float split = (float)1 / (float)this->max;
		if (valuePercent > currPos && valuePercent <= (currPos + split))
		{
			mvwprintw(this->win, 0, i, ".");
		}
		else if (valuePercent > currPos)
		{
			mvwprintw(this->win, 0, i, "|");
		}
		else if (valuePercent == 0 && currPos == 0)
		{
			mvwprintw(this->win, 0, i, "_");
		}
	}

	wrefresh(this->win);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3050
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x857a
cvtsi2ssl 0x8(%rbx), %xmm3
cvtsi2ssl 0xc(%rbx), %xmm0
cvtsi2ss %ebp, %xmm1
movss %xmm1, 0x4(%rsp)
divss %xmm0, %xmm3
leaq 0x403f(%rip), %r15      # 0xc516
leaq 0x4036(%rip), %r12      # 0xc514
leaq 0x4033(%rip), %r13      # 0xc518
xorl %ebp, %ebp
movss %xmm3, (%rsp)
movq (%rax,%rbp,8), %rax
xorps %xmm0, %xmm0
cvtsi2ssl (%rax), %xmm0
divss 0x4(%rsp), %xmm0
ucomiss %xmm3, %xmm0
jbe 0x852b
xorps %xmm1, %xmm1
cvtsi2ssl 0xc(%rbx), %xmm1
movss 0x3ffa(%rip), %xmm2     # 0xc50c
divss %xmm1, %xmm2
addss %xmm3, %xmm2
ucomiss %xmm0, %xmm2
movq (%rbx), %rdi
jae 0x854d
xorl %esi, %esi
movl %ebp, %edx
movq %r15, %rcx
jmp 0x8554
ucomiss 0x3fde(%rip), %xmm0     # 0xc510
jne 0x8560
jp 0x8560
ucomiss 0x3fd3(%rip), %xmm3     # 0xc510
jne 0x8560
jp 0x8560
movq (%rbx), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %r13, %rcx
jmp 0x8554
xorl %esi, %esi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x30b0
movss (%rsp), %xmm3
incq %rbp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
jb 0x84ec
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Create(int, int, int, int)
void GraphTitle::Create(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

	this->Update();
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
movl %r8d, %edi
movl %ecx, %esi
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x85c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Update()
void GraphTitle::Update()
{
	werase(this->win);

	char graphTypeString[graphTypeStringSize];
	getGraphTypeString(this->graphType, graphTypeString);

	if (this->active)
	{
		wattron(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
	}
	if (this->interface == NULL)
	{
		wprintw(this->win, "%s", graphTypeString);
	}
	else
	{
		wprintw(this->win, "%s through %s", graphTypeString, interface->name);
	}
	if (this->active)
	{
		wattroff(this->win, COLOR_PAIR(HEADER_ACTIVE_COLOR));
	}

	wrefresh(this->win);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3050
movl 0x18(%rbx), %edi
movq %rsp, %rsi
callq 0xa46b
cmpb $0x1, 0x28(%rbx)
jne 0x85f8
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x861a
movq (%rax), %rcx
leaq 0x3f0c(%rip), %rsi      # 0xc51a
movq %rsp, %rdx
xorl %eax, %eax
callq 0x3060
jmp 0x862b
leaq 0x40ed(%rip), %rsi      # 0xc70e
movq %rsp, %rdx
xorl %eax, %eax
callq 0x3060
cmpb $0x1, 0x28(%rbx)
jne 0x8640
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x33b0
movq (%rbx), %rdi
callq 0x3310
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphTitle::Resize(int, int, int, int)
void GraphTitle::Resize(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

	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)
movl %r8d, 0x14(%rdi)
movq (%rdi), %rdi
movl %r8d, %esi
movl %ecx, %edx
callq 0x31f0
movq (%rbx), %rdi
movl 0xc(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3150
movq %rbx, %rdi
popq %rbx
jmp 0x85c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: GraphMaxItem::Create(int, int, int, int)
void GraphMaxItem::Create(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

	wrefresh(this->win);
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
incl %edx
movl %r8d, %edi
movl %ecx, %esi
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/graph.cpp
// Function: Graph::Graph(GraphType, std::vector<Interface*, std::allocator<Interface*>>*)
Graph::Graph(GraphType graphType, std::vector<Interface *> *interfaces)
{
	this->graphType = graphType;
	this->interfaces = interfaces;

	this->graphTitle = new GraphTitle(this->graphType, NULL);
	this->graphMaxItem = new GraphMaxItem();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq $0x0, 0x28(%rdi)
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movl %esi, 0x30(%rdi)
movq %rdx, 0x20(%rdi)
movl $0x30, %edi
callq 0x32c0
movb $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
movl %ebp, 0x18(%rax)
movq %rax, 0x38(%rbx)
movl $0x20, %edi
callq 0x32c0
movl $0x0, 0x18(%rax)
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x87c1
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x32d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3604
movq %r15, %rdi
callq 0x3550
// File: /workspace/github_cpp_makefile_star2_O1/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 0x87e6
movq %rax, 0x68(%rbx)
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x87f4
movq %rax, 0x50(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8807
movl $0x30, %esi
callq 0x32d0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x881a
movl $0x20, %esi
callq 0x32d0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x882f
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x32d0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x8845
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x32d0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d8a
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
callq 0x81bc
incq %r14
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x8d6a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8d9a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8de0
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 0x8dcb
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 0x8e3e
leaq 0x60(%rbx), %r15
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x8490
incq %r12
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x8e18
movq 0x40(%rbx), %rdi
movl %r14d, 0x18(%rdi)
callq 0x870c
movq 0x38(%rbx), %rdi
callq 0x85c8
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e9d
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 0x8e8b
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x8ed6
leaq 0x60(%rbx), %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x8490
incq %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x8eae
movq 0x40(%rbx), %rdi
movl $0x0, 0x18(%rdi)
callq 0x870c
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x85c8
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x8f41
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq %r14, 0x10(%rdi)
callq 0x81bc
incq %r15
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x8f1d
movq %rbx, %rdi
callq 0x8e68
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8d56
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9494
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leaq 0x328e(%rip), %rsi      # 0xc70e
movq %r14, %rdx
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
jmp 0x94c4
movq (%rbx), %rdi
cmpl %esi, 0x8(%rbx)
jne 0x94e1
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
leaq 0x325c(%rip), %rsi      # 0xc70e
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 0x3226(%rip), %rsi      # 0xc70e
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9543
movl 0x14(%rbx), %r8d
leaq 0x30d4(%rip), %rcx      # 0xc600
leaq 0x30d1(%rip), %r9       # 0xc604
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x30b0
jmp 0x9590
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x3180
movq (%rbx), %rdi
movl 0x14(%rbx), %r8d
leaq 0x30a3(%rip), %rcx      # 0xc600
leaq 0x30a0(%rip), %r9       # 0xc604
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 0x2ca9(%rip), %r14      # 0xc243
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x3068(%rip), %rdx      # 0xc613
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9458
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x3055(%rip), %rdx      # 0xc621
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9458
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x303e(%rip), %rdx      # 0xc62b
movq %rbx, %rdi
movl $0x3, %esi
callq 0x9458
movq (%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3060
leaq 0x302b(%rip), %rdx      # 0xc639
movq %rbx, %rdi
movl $0x4, %esi
callq 0x9458
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_O1/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: InterfaceRow::InterfaceRow(int, int, int, int)
InterfaceRow::InterfaceRow(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
movl $0x3, %edi
movl %ecx, %esi
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: Interface::Interface(char*, int, bool)
Interface::Interface(char *name, int longest, bool wireless)
{
	this->longest = longest;
	this->wireless = wireless;
	this->name = new char[strlen(name) + 1];
	strcpy(this->name, name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x9c(%rdi)
movq %rax, 0xa8(%rdi)
movw $0x0, 0xb0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x68(%rdi)
movl %edx, 0xb4(%rdi)
movb %cl, 0x8c(%rdi)
movq %rsi, %rdi
callq 0x3170
leaq 0x1(%rax), %rdi
callq 0x3030
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: Interface::Zero()
void Interface::Zero()
{
	r_bytesZeroed = r_bytes;
	t_bytesZeroed = t_bytes;
	r_packetsZeroed = r_packets;
	t_packetsZeroed = t_packets;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movq %rax, 0x20(%rdi)
movq %rcx, 0x40(%rdi)
movq 0x48(%rdi), %rax
movq %rax, 0x58(%rdi)
movq 0x60(%rdi), %rax
movq %rax, 0x70(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: Interface::UnZero()
void Interface::UnZero()
{
	r_bytesZeroed = 0;
	t_bytesZeroed = 0;
	r_packetsZeroed = 0;
	t_packetsZeroed = 0;
}

// Assembly:
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x40(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x70(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/interface.cpp
// Function: InterfaceDetailWindow::InterfaceDetailWindow(int, int, int, int, Interface*)
InterfaceDetailWindow::InterfaceDetailWindow(int placementX, int placementY, int width, int height, Interface *interface)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

	this->interface = interface;

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

	this->Update();
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl $0xffffffff, 0x20(%rdi) # imm = 0xFFFFFFFF
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
movq %r9, 0x18(%rdi)
movl %r8d, %edi
movl %ecx, %esi
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xa088
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f7e(%rip), %rax      # 0x10328
movq (%rax), %r15
movq 0x8(%rax), %r12
subq %r15, %r12
je 0xa3e3
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 0xa3e6
incq %r13
cmpq %r13, %r12
jne 0xa3c8
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x222d(%rip), %rdi      # 0xc8bb
callq 0x33a0
movq %rax, %r14
testq %rax, %rax
jne 0xa6ab
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 0xa4a5
movb %al, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa6e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3550
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa791
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 0xa8f3
movq %rsp, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3200
leaq 0x1b3d(%rip), %rsi      # 0xc2e2
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 0x1b19(%rip), %rsi      # 0xc2f0
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 0x1ad5(%rip), %rsi      # 0xc2db
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 0x1a99(%rip), %rsi      # 0xc2db
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 0x1a5a(%rip), %rsi      # 0xc2db
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 0x1a1b(%rip), %rsi      # 0xc2db
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 0xa928
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xa908
jmp 0xa908
jmp 0xa908
jmp 0xa908
jmp 0xa908
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x3550
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
jmp 0xa913
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a24(%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 0xa5cc
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xa999
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 0xa9d2
movq %rbx, %rdi
callq 0x3170
leaq 0x98(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3320
jmp 0xa9f4
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 0xaa0b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
leaq 0x98(%rsp), %rdi
callq 0x3420
leaq 0x28(%rsp), %rdi
callq 0xaac0
movq 0x55a7(%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 0xaa98
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0xaa89
jmp 0xaa9b
jmp 0xaa98
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0xaa9b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xaac0
leaq 0x98(%rsp), %rdi
callq 0x3430
movq %rbx, %rdi
callq 0x3550
movq %rax, %rbx
jmp 0xaaa5
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/selectionWindow.cpp
// Function: SelectionWindow::SelectionWindow(GraphType, int, int, int, int)
SelectionWindow::SelectionWindow(GraphType graphType, int placementX, int placementY, int width, int height)
{
	this->graphType = graphType;
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

	this->Update();
}

// Assembly:
pushq %rbx
movl %edx, %eax
movq %rdi, %rbx
movl $0xffffffff, 0x1c(%rdi) # imm = 0xFFFFFFFF
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
movl %r9d, 0x18(%rdi)
movl %r9d, %edi
movl %r8d, %esi
movl %ecx, %edx
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xabaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b22(%rip), %r15      # 0xc70e
xorl %r12d, %r12d
movl %r12d, %edi
movq %r14, %rsi
callq 0xa46b
cmpl 0x1c(%rbx), %r12d
jne 0xac0f
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 0xac40
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x33b0
movl %ebp, %r12d
cmpl $0x4, %ebp
jne 0xabef
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_O1/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 0x8f68
movl %eax, 0xc(%rbx)
movq 0x20(%rbx), %rdi
callq 0x8f6c
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 0xabaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/footer.cpp
// Function: Footer::Footer(int, int, int, int)
Footer::Footer(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
movl %esi, 0xc(%rdi)
movl %edx, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movl %r8d, 0x18(%rdi)
movl %r8d, %edi
movl %ecx, %esi
movl %eax, %ecx
callq 0x32e0
movq %rax, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Stygain[P]bandwidth-monitor/src/footer.cpp
// Function: Footer::Resize(int, int, int, int)
void Footer::Resize(int placementX, int placementY, int width, int height)
{
	this->placementX = placementX;
	this->placementY = placementY;
	this->width = width;
	this->height = height;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0xc(%rdi)
movl %edx, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movl %r8d, 0x18(%rdi)
movq (%rdi), %rdi
movl %r8d, %esi
movl %ecx, %edx
callq 0x31f0
movq (%rbx), %rdi
movl 0x10(%rbx), %esi
movl 0xc(%rbx), %edx
popq %rbx
jmp 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa44c
movq (%rbx), %rdi
leaq 0x1aec(%rip), %rsi      # 0xc8d4
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 0xae94
leaq 0x1aa7(%rip), %rcx      # 0xc8c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b20(%rip), %rsi      # 0xc949
leaq 0x1ae8(%rip), %rdx      # 0xc918
leaq 0x1abb(%rip), %rcx      # 0xc8f2
xorl %eax, %eax
callq 0x3060
jmp 0xaee6
leaq 0x1afa(%rip), %rsi      # 0xc944
leaq 0x1a8e(%rip), %rdx      # 0xc8df
leaq 0x1a9a(%rip), %rcx      # 0xc8f2
leaq 0x1a9a(%rip), %r8       # 0xc8f9
xorl %eax, %eax
callq 0x3060
jmp 0xaee6
leaq 0x1ad0(%rip), %rsi      # 0xc93f
leaq 0x1a69(%rip), %rdx      # 0xc8df
leaq 0x1a75(%rip), %rcx      # 0xc8f2
leaq 0x1a80(%rip), %r8       # 0xc904
leaq 0x1a81(%rip), %r9       # 0xc90c
xorl %eax, %eax
callq 0x3060
jmp 0xaee6
leaq 0x1ad9(%rip), %r10      # 0xc974
leaq 0x1acb(%rip), %r11      # 0xc96d
leaq 0x1abc(%rip), %r14      # 0xc965
leaq 0x1aaa(%rip), %r15      # 0xc95a
leaq 0x1a74(%rip), %rsi      # 0xc92b
leaq 0x1a5a(%rip), %rdx      # 0xc918
leaq 0x1a2d(%rip), %rcx      # 0xc8f2
leaq 0x1a2d(%rip), %r8       # 0xc8f9
leaq 0x1a80(%rip), %r9       # 0xc953
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_O1/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 0x5462(%rip), %r15      # 0x10390
movq (%r15), %rdi
leaq 0x1236(%rip), %r14      # 0xc16e
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 0xaf88
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5170(%rip), %rax      # 0x10390
movq (%rax), %rdi
leaq 0xf44(%rip), %rsi       # 0xc16e
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 0xaf88
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27e4
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x29ca(%rip), %rsi      # 0x50a9
leaq 0x29d9(%rip), %rdx      # 0x50bf
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4296
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b1c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x270b
callq 0x2140
callq 0x27e4
movq %rax, %rdi
callq 0x2b7c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2734
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28e6(%rip), %rdi      # 0x5043
xorl %eax, %eax
callq 0x2030
leaq 0x2955(%rip), %rdi      # 0x50c0
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2030
leaq 0x28ca(%rip), %rdi      # 0x5049
xorl %eax, %eax
callq 0x2030
callq 0x27e4
movq %rax, %r12
leaq -0xa0(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x301a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e02
leaq -0xa0(%rbp), %rdi
callq 0x308a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x308a
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x328a
testq %rax, %rax
je 0x2b47
addq $0x28, %rax
movq %rax, 0x50(%r14)
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x40dc
leaq 0x24e9(%rip), %rdi      # 0x5037
xorl %eax, %eax
callq 0x2030
movq (%rbx), %rsi
leaq 0x26e9(%rip), %rdi      # 0x5248
xorl %eax, %eax
callq 0x2030
leaq 0x24dc(%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_O1/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 0x27e0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25b7
callq 0x2190
callq 0x4307
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 0x2746
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_O1/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 0x29a2(%rip), %rdx      # 0x51a5
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x2746
cmpq $0x0, 0x8(%rbx)
je 0x2882
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
movabsq $0x100000600, %r12      # imm = 0x100000600
leaq 0x2977(%rip), %r15      # 0x51a5
movq (%rbx), %rax
movzbl (%rax,%r13), %eax
cmpq $0x20, %rax
ja 0x286e
btq %rax, %r12
jae 0x286e
cmpq $0x0, -0x40(%rbp)
je 0x2858
leaq 0x5928(%rip), %rdi      # 0x8178
movq %r14, %rsi
callq 0x2960
movq -0x40(%rbp), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x2210
jmp 0x2879
movsbl %al, %esi
movq %r14, %rdi
callq 0x2160
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x282e
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x27bc(%rip), %rsi      # 0x504d
leaq 0x27b6(%rip), %rdx      # 0x504e
leaq -0x68(%rbp), %rdi
callq 0x2746
leaq 0x58d0(%rip), %rdi      # 0x8178
leaq -0x68(%rbp), %rsi
callq 0x2bfa
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x28bf
callq 0x2190
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x28d1
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 0x28f8
callq 0x2190
jmp 0x28f8
jmp 0x28f5
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x290a
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x340f
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 0x3412
leal (%rax,%rax,4), %eax
leal (%rdi,%rax,2), %eax
addl $-0x30, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x33ee
jmp 0x3417
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35e4
leaq 0x1ba8(%rip), %rax      # 0x506c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1bfc(%rip), %rsi      # 0x50d0
leaq 0x1bf9(%rip), %rdx      # 0x50d4
jmp 0x3652
leaq 0x1c37(%rip), %rsi      # 0x511e
leaq 0x1c33(%rip), %rdx      # 0x5121
jmp 0x3652
leaq 0x1c1c(%rip), %rsi      # 0x5116
leaq 0x1c19(%rip), %rdx      # 0x511a
jmp 0x3652
leaq 0x1bf6(%rip), %rsi      # 0x5103
leaq 0x1bf6(%rip), %rdx      # 0x510a
jmp 0x3652
leaq 0x1bc2(%rip), %rsi      # 0x50e2
leaq 0x1bbe(%rip), %rdx      # 0x50e5
jmp 0x3652
leaq 0x1bd8(%rip), %rsi      # 0x510b
leaq 0x1bd7(%rip), %rdx      # 0x5111
jmp 0x3652
leaq 0x1bb1(%rip), %rsi      # 0x50f7
leaq 0x1bad(%rip), %rdx      # 0x50fa
jmp 0x3652
leaq 0x1b80(%rip), %rsi      # 0x50d9
leaq 0x1b7d(%rip), %rdx      # 0x50dd
jmp 0x3652
leaq 0x1baf(%rip), %rsi      # 0x511b
leaq 0x1baa(%rip), %rdx      # 0x511d
jmp 0x3652
leaq 0x1b5f(%rip), %rsi      # 0x50de
leaq 0x1b5b(%rip), %rdx      # 0x50e1
jmp 0x3652
leaq 0x1b5d(%rip), %rsi      # 0x50ef
leaq 0x1b59(%rip), %rdx      # 0x50f2
jmp 0x3652
leaq 0x1b30(%rip), %rsi      # 0x50d5
leaq 0x1b2c(%rip), %rdx      # 0x50d8
jmp 0x3652
leaq 0x1b6a(%rip), %rsi      # 0x5122
leaq 0x1b66(%rip), %rdx      # 0x5125
jmp 0x3652
leaq 0x1a82(%rip), %rsi      # 0x504d
leaq 0x1a7c(%rip), %rdx      # 0x504e
jmp 0x3652
leaq 0x1b0b(%rip), %rsi      # 0x50e6
leaq 0x1b07(%rip), %rdx      # 0x50e9
jmp 0x3652
leaq 0x1b45(%rip), %rsi      # 0x5130
leaq 0x1b4d(%rip), %rdx      # 0x513f
jmp 0x3652
leaq 0x1b17(%rip), %rsi      # 0x5112
leaq 0x1b13(%rip), %rdx      # 0x5115
jmp 0x3652
leaq 0x1adf(%rip), %rsi      # 0x50ea
leaq 0x1adc(%rip), %rdx      # 0x50ee
jmp 0x3652
leaq 0x1b0b(%rip), %rsi      # 0x5126
leaq 0x1b08(%rip), %rdx      # 0x512a
jmp 0x3652
leaq 0x1ad0(%rip), %rsi      # 0x50fb
leaq 0x1ad0(%rip), %rdx      # 0x5102
jmp 0x3652
leaq 0x1ab8(%rip), %rsi      # 0x50f3
leaq 0x1ab4(%rip), %rdx      # 0x50f6
jmp 0x3652
leaq 0x1ae0(%rip), %rsi      # 0x512b
leaq 0x1add(%rip), %rdx      # 0x512f
movq %rbx, %rdi
callq 0x2746
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40ee(%rip), %rax      # 0x81f0
leaq 0x406f(%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 0x4081(%rip), %rdi      # 0x81b8
movq %rbx, %rsi
callq 0x43ce
cmpl $0x15, (%rax)
je 0x41a2
leaq 0x406d(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x2, (%rax)
je 0x41a2
leaq 0x4058(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x2, (%rax)
je 0x41b9
leaq 0x4043(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x12, (%rax)
je 0x41b9
leaq 0x402e(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x13, (%rax)
je 0x41b9
callq 0x3901
callq 0x40f0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x41b0
callq 0x2190
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10be(%rip), %rsi      # 0x527e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x444d
leaq -0x50(%rbp), %rdi
callq 0x2e00
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41f0
callq 0x2190
jmp 0x41f0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x41fe
callq 0x2190
movq %rbx, %rdi
callq 0x2270