LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::MateriaSource(MateriaSource const&)
MateriaSource::MateriaSource(const MateriaSource &other):
	current(0)
{
	for (int i = 0; i < other.current; i++)
		this->learnMateria(other.sources[i]->clone());
	for (int i = 0; i < 4; i++)
		this->sources[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3036(%rip), %rax      # 0x5d70
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
cmpl $0x0, 0x8(%rsi)
jle 0x2d73
movq %rsi, %r14
xorl %r15d, %r15d
movq 0x10(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x2d50
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::operator=(MateriaSource const&)
MateriaSource &MateriaSource::operator=(const MateriaSource &other)
{
	for (int i = 0; i < this->current; i++)
		delete this->sources[i];
	this->current = 0;
	for (int i = 0; i < other.current; i++)
		this->learnMateria(other.sources[i]->clone());
	for (int i = 0; i < 4; i++)
		this->sources[i] = 0;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x2e47
xorl %r15d, %r15d
movq 0x10(%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x2e3b
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x2e2b
movl $0x0, 0x8(%rbx)
cmpl $0x0, 0x8(%r14)
jle 0x2e7b
xorl %r15d, %r15d
movq 0x10(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x2e58
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::learnMateria(AMateria*)
void MateriaSource::learnMateria(AMateria *m)
{
	if (this->current  == 4 || m == 0)
		return ;
	for (int i = 0; i < this->current; i++)
	{
		if (this->sources[i] == m)
			return ;
	}
	this->sources[this->current++] = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
cmpq $0x4, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x2ee9
testl %eax, %eax
setg %cl
jle 0x2edc
cmpq %rsi, 0x10(%rdi)
je 0x2ed8
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2edc
leaq 0x1(%rdx), %r8
cmpq %rsi, 0x18(%rdi,%rdx,8)
movq %r8, %rdx
jne 0x2ebf
cmpq %rax, %r8
setb %cl
testb %cl, %cl
jne 0x2ee9
movslq %eax, %rcx
incl %eax
movl %eax, 0x8(%rdi)
movq %rsi, 0x10(%rdi,%rcx,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::createMateria(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AMateria* MateriaSource::createMateria(const std::string &type)
{
	for (int i = 0; i < this->current; i++)
	{
		if (this->sources[i]->getType() == type)
			return (this->sources[i]->clone());
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
jle 0x2f39
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x10(%rbx,%r15,8), %rdi
callq 0x2434
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x2f2d
testq %rdx, %rdx
je 0x2f46
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x20e0
testl %eax, %eax
je 0x2f46
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x2f05
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx,%r15,8), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/factory.cpp
// Function: Factory::collect_relevant_facilities(item_t) const
vector<size_t> Factory::collect_relevant_facilities(item_t item) const
{
	vector<size_t> relevant_facilities;

	for (size_t facility_id = 0; facility_id < facilities.size(); facility_id++)
	{
		const auto& facility = facilities[facility_id];

		if (facility.items.find(item) != facility.items.end())
		{
			relevant_facilities.push_back(facility_id);
		}
		#ifndef NDEBUG
		else // assert that there is no `item`-edge from or to that facility
		{
			for (const auto& transport_line : transport_lines)
				if (transport_line.item_type == item)
					assert(transport_line.from != facility_id
						&& transport_line.to != facility_id);
		}
		#endif
	}
	
	return relevant_facilities;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x8(%rsp)
movq (%rsi), %rcx
cmpq %rcx, 0x8(%rsi)
je 0x5224
movl %edx, %ebp
movq %rsi, %r14
xorl %eax, %eax
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x8(%rsp), %r15
leaq (%rax,%rax,4), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $0x28, %rcx
movq 0x8(%rcx), %rsi
movq %rcx, %rdx
testq %rsi, %rsi
je 0x51a0
movq %rcx, %rdx
xorl %edi, %edi
cmpl %ebp, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x5189
movq %rcx, %rsi
cmpq %rcx, %rdx
je 0x51b2
cmpl %ebp, 0x20(%rdx)
cmovgq %rcx, %rdx
movq %rdx, %rsi
cmpq %rcx, %rsi
je 0x51ce
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x51f1
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x51fc
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
cmpq %rdx, %rcx
je 0x51fc
cmpl %ebp, (%rcx)
jne 0x51eb
cmpq %rax, 0x8(%rcx)
je 0x5234
cmpq %rax, 0x10(%rcx)
je 0x5234
addq $0x30, %rcx
jmp 0x51d6
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6bc4
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
imulq %r12, %rdx
cmpq %rdx, %rax
jb 0x516b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa04e(%rip), %rdi      # 0xf289
leaq 0xa08e(%rip), %rsi      # 0xf2d0
leaq 0xa093(%rip), %rcx      # 0xf2dc
movl $0x2d, %edx
callq 0x3180
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x526a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3250
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/factory.cpp
// Function: Factory::build_facility_itemset()
void Factory::build_facility_itemset()
{
	for (const auto& tl : transport_lines)
	{
		facilities[tl.from].items.insert(tl.item_type);
		facilities[tl.to].items.insert(tl.item_type);
	}

	for (auto& fac : facilities)
		fac.most_advanced_item_involved = *fac.items.rbegin();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x52e5
movq 0x8(%r14), %rax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x67fc
movq 0x10(%r14), %rax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x67fc
addq $0x30, %r14
jmp 0x529c
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x5314
addq $0x28, %r14
movq %r14, %rdi
callq 0x3170
movl 0x20(%rax), %eax
movl %eax, -0x10(%r14)
leaq 0x50(%r14), %rax
addq $0x28, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x52f5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/factory.cpp
// Function: Factory::build_edge_table()
void Factory::build_edge_table()
{
	edge_table_per_item.resize(MAX_ITEM);
	edge_table_per_item_inv.resize(MAX_ITEM);

	for (size_t item = 0; item < MAX_ITEM; item++)
	{
		edge_table_per_item[item].clear();
		edge_table_per_item_inv[item].resize(transport_lines.size());

		for (size_t i = 0; i < transport_lines.size(); i++)
			if (transport_lines[i].item_type == item)
			{
				edge_table_per_item[item].push_back(i);
				edge_table_per_item_inv[item][i] = edge_table_per_item[item].size()-1;
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movl $0xb, %esi
movq %r14, %rdi
callq 0x61aa
leaq 0x78(%rbx), %r15
movl $0xb, %esi
movq %r15, %rdi
callq 0x61aa
xorl %r13d, %r13d
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq %r15, 0x10(%rsp)
movq (%r14), %rax
leaq (,%r13,2), %r12
addq %r13, %r12
movq (%rax,%r12,8), %rcx
cmpq %rcx, 0x8(%rax,%r12,8)
je 0x5798
leaq (%rax,%r12,8), %rax
movq %rcx, 0x8(%rax)
leaq (,%r12,8), %rdi
addq 0x78(%rbx), %rdi
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x4, %rsi
imulq %rbp, %rsi
callq 0x61e6
movq $0x0, 0x8(%rsp)
movq 0x18(%rbx), %rcx
cmpq %rcx, 0x20(%rbx)
movq 0x10(%rsp), %r8
je 0x586d
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %r15
xorl %eax, %eax
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movslq (%rcx,%rdx), %rcx
cmpq %rcx, %r13
jne 0x5844
movq (%r14), %rcx
leaq (%rcx,%r12,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5812
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5821
leaq 0x8(%rsp), %rdx
callq 0x6bc4
movq 0x10(%rsp), %r8
movq (%r14), %rax
movq 0x8(%rax,%r15), %rcx
subq (%rax,%r15), %rcx
sarq $0x3, %rcx
decq %rcx
movq (%r8), %rax
movq 0x8(%rsp), %rdx
movq (%rax,%r15), %rax
movq %rcx, (%rax,%rdx,8)
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
imulq %rbp, %rdx
cmpq %rdx, %rax
jb 0x57e3
incq %r13
cmpq $0xb, %r13
jne 0x5777
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::Node::update_backward()
void FlowGraph::Node::update_backward()
{
	if (excess <= 0)
		return;

	int amount = incoming() - excess;

	multimap<int, Edge*> sorted_edges;
	for (Edge* edge : incoming_edges)
		sorted_edges.insert( std::pair<int, Edge*>(edge->actual_flow, edge) );

	size_t edges_remaining = sorted_edges.size();
	int amount_remaining = amount;

	for (auto& it : sorted_edges)
	{
		Edge* edge = it.second;
		auto capacity = it.first;

		int fair_share = amount_remaining / edges_remaining; // beware: integer division
		if (fair_share < capacity)
			edge->actual_capacity = fair_share;
		else
		{
			edge->actual_capacity = capacity; // set edge flow to maximum possible value
			amount_remaining -= capacity; // the remaining amount must now be shared over even less edges
			edges_remaining--;
		}

		assert(amount_remaining >= 0);
	}

	assert(edges_remaining > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x7bea
movl %eax, 0x4(%rsp)
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rax
xorl %ebp, %ebp
cmpq %rax, %r13
je 0x7b42
movq %r13, %rcx
movq (%rcx), %rdx
addl 0x8(%rdx), %ebp
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x7b33
leaq 0x20(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
movq 0x18(%rdi), %r12
cmpq %r12, %r13
je 0x7b97
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq (%r13), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b9e
addq $0x8, %r13
cmpq %r12, %r13
jne 0x7b73
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rbx
cmpq %r15, %rdi
je 0x7bdb
subl 0x4(%rsp), %ebp
movq 0x28(%rdi), %rcx
movl 0x20(%rdi), %esi
movslq %ebp, %rax
xorl %edx, %edx
divq %rbx
cmpl %eax, %esi
jle 0x7bc2
movl %eax, 0x4(%rcx)
jmp 0x7bca
movl %esi, 0x4(%rcx)
subl %esi, %ebp
decq %rbx
testl %ebp, %ebp
js 0x7bf9
callq 0x31b0
movq %rax, %rdi
cmpq %r15, %rax
jne 0x7baa
testq %rbx, %rbx
je 0x7c18
leaq 0x18(%rsp), %rdi
callq 0x9b4e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7929(%rip), %rdi      # 0xf529
leaq 0x7938(%rip), %rsi      # 0xf53f
leaq 0x7966(%rip), %rcx      # 0xf574
movl $0x78, %edx
callq 0x3180
leaq 0x797d(%rip), %rdi      # 0xf59c
leaq 0x7919(%rip), %rsi      # 0xf53f
leaq 0x7947(%rip), %rcx      # 0xf574
movl $0x7b, %edx
callq 0x3180
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x9b4e
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::calculate()
void FlowGraph::calculate()
{
	//dump("initial");
	bool done;
	int i = 0;
	do
	{
		for (auto& node : nodes)
			node.update_forward();

		//dump("it"+to_string(i));

		for (auto& node : nodes)
			node.update_backward();

		done = true;
		for (auto& node : nodes)
			if (node.excess > 0)
				done = false;

		//dump("it"+to_string(i)+".5");
		i++;
	} while(!done);
	dump("FINAL");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x7c75
movq %r14, %rdi
callq 0x797c
addq $0x40, %r14
jmp 0x7c62
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x7c8f
movq %r14, %rdi
callq 0x7b04
addq $0x40, %r14
jmp 0x7c7c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x7cb5
movb $0x1, %dl
cmpl $0x0, 0x8(%rax)
movzbl %dl, %edx
cmovgl %ebp, %edx
addq $0x40, %rax
cmpq %rcx, %rax
jne 0x7c9d
testb $0x1, %dl
je 0x7c5b
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x78eb(%rip), %rsi      # 0xf5b0
leaq 0x78e9(%rip), %rdx      # 0xf5b5
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4f78
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d28
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7cfb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3250
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7d20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3250
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::edge_from(FlowGraph::Edge const*) const
size_t FlowGraph::edge_from(const Edge* edge) const
{
	for (size_t i=0; i<nodes.size(); i++)
	{
		for (const Edge* e : nodes[i].outgoing_edges)
			if (e == edge)
				return i;
	}

	throw runtime_error("FlowGraph is corrupt");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
subq %rdx, %rdi
setne %cl
je 0x9943
sarq $0x6, %rdi
cmpq $0x1, %rdi
movq %rdi, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movq %r9, %r10
shlq $0x6, %r10
movq 0x28(%rdx,%r10), %rbx
movq 0x30(%rdx,%r10), %r11
cmpq %r11, %rbx
sete %r10b
je 0x992e
cmpq %rsi, (%rbx)
cmoveq %r9, %rax
je 0x992e
addq $0x8, %rbx
cmpq %r11, %rbx
sete %r10b
je 0x992e
cmpq %rsi, (%rbx)
leaq 0x8(%rbx), %rbx
cmoveq %r9, %rax
jne 0x9918
testb %r10b, %r10b
je 0x9943
incq %r9
cmpq %rdi, %r9
setb %cl
cmpq %r8, %r9
jne 0x98f1
jmp 0x9943
testb $0x1, %cl
je 0x9950
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x5c85(%rip), %rsi      # 0xf5e9
movq %rax, %rdi
callq 0x30e0
movq 0xb67d(%rip), %rsi      # 0x14ff0
movq 0xb646(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O1/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::edge_to(FlowGraph::Edge const*) const
size_t FlowGraph::edge_to(const Edge* edge) const
{
	for (size_t i=0; i<nodes.size(); i++)
	{
		for (const Edge* e : nodes[i].incoming_edges)
			if (e == edge)
				return i;
	}

	throw runtime_error("FlowGraph is corrupt");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
subq %rdx, %rdi
setne %cl
je 0x9a0d
sarq $0x6, %rdi
cmpq $0x1, %rdi
movq %rdi, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movq %r9, %r10
shlq $0x6, %r10
movq 0x10(%rdx,%r10), %rbx
movq 0x18(%rdx,%r10), %r11
cmpq %r11, %rbx
sete %r10b
je 0x99f8
cmpq %rsi, (%rbx)
cmoveq %r9, %rax
je 0x99f8
addq $0x8, %rbx
cmpq %r11, %rbx
sete %r10b
je 0x99f8
cmpq %rsi, (%rbx)
leaq 0x8(%rbx), %rbx
cmoveq %r9, %rax
jne 0x99e2
testb %r10b, %r10b
je 0x9a0d
incq %r9
cmpq %rdi, %r9
setb %cl
cmpq %r8, %r9
jne 0x99bb
jmp 0x9a0d
testb $0x1, %cl
je 0x9a1a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x5bbb(%rip), %rsi      # 0xf5e9
movq %rax, %rdi
callq 0x30e0
movq 0xb5b3(%rip), %rsi      # 0x14ff0
movq 0xb57c(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/multiset.cc
// Function: main
int main()
{
	// uses hash<Sales_data> and Sales_data operator==
	unordered_multiset<Sales_data> SDset;
	Sales_data item;
	while (cin >> item) {
		SDset.insert(item);
	}
	cout << SDset.size() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x68(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x50(%rbp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
movl $0x0, 0x10(%r13)
movq %rax, 0x18(%r13)
movq 0x3c1b(%rip), %rbx      # 0x5fe0
leaq -0x60(%rbp), %r14
leaq -0x98(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c7b
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2403
movq %r15, -0x30(%rbp)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2562
jmp 0x23d4
movq -0x80(%rbp), %rsi
movq 0x3bc2(%rip), %rdi      # 0x5fd0
callq 0x20a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x2452
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0x98(%rbp), %rdi
callq 0x24ac
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2471
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x2489
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0x98(%rbp), %rdi
callq 0x24ac
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: radix2fft
void radix2fft(const double *input, double *output, unsigned stride) {
    output[0] = input[0] + input[stride << 1];
    output[1] = input[1] + input[(stride << 1) + 1];

    output[2] = input[0] - input[(stride << 1)];
    output[3] = input[1] - input[(stride << 1) + 1];
}

// Assembly:
movsd (%rdi), %xmm0
addl %edx, %edx
addsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rsi)
movsd 0x8(%rdi), %xmm0
addsd 0x8(%rdi,%rdx,8), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd (%rdi), %xmm0
subsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, 0x10(%rsi)
movsd 0x8(%rdi), %xmm0
subsd 0x8(%rdi,%rdx,8), %xmm0
movsd %xmm0, 0x18(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: sum2fft
void sum2fft(const double *input, double *output, unsigned size, int inverse) {
    unsigned k;

    double temp[4], cosfi, sinfi,
        dfi = (inverse ? 2.0 : -2.0) * M_PI / (double)(size << 1),
        kfi = 0.0;

    for (k = 0; k < size; k++) {
        cosfi = cos(kfi); sinfi = sin(kfi);
        temp[0] = input[k << 1]; temp[1] = input[(k << 1) + 1];
        temp[2] = input[(k + size) << 1]; temp[3] = input[((k + size) << 1) + 1];

        output[k << 1] = temp[0] + cosfi * temp[2] - sinfi * temp[3];
        output[(k << 1) + 1] = temp[1] + sinfi * temp[2] + cosfi * temp[3];
        output[(k + size) << 1] = temp[0] - cosfi * temp[2] + sinfi * temp[3];
        output[((k + size) << 1) + 1] = temp[1] - sinfi * temp[2] - cosfi * temp[3];
        kfi += dfi;
    }
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
testl %edx, %edx
je 0x131b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb %cl, %al
leaq 0xdfa(%rip), %rcx       # 0x2010
leal (%rdx,%rdx), %r15d
cvtsi2sd %r15, %xmm0
movsd (%rcx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movl %edx, %r12d
leaq 0x1(%r15), %r13
addq %r12, %r12
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x1070
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1090
movl %ebp, %eax
andl $-0x2, %eax
shlq $0x3, %rax
leal (%r15,%rbp), %ecx
movsd (%r14,%rcx,8), %xmm3
leal (%r13,%rbp), %edx
movsd (%r14,%rdx,8), %xmm2
movapd %xmm0, %xmm1
xorpd 0xd9a(%rip), %xmm1      # 0x2020
movapd 0x10(%rsp), %xmm7
movapd %xmm7, %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
movapd %xmm7, %xmm5
mulsd %xmm3, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm0
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
movupd (%r14,%rax), %xmm4
addpd %xmm4, %xmm3
unpcklpd %xmm7, %xmm1            # xmm1 = xmm1[0],xmm7[0]
mulsd %xmm2, %xmm6
mulsd %xmm2, %xmm7
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
movupd %xmm2, (%rbx,%rax)
movapd %xmm4, %xmm1
subsd %xmm5, %xmm1
addsd %xmm1, %xmm6
movsd %xmm6, (%rbx,%rcx,8)
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
subsd %xmm0, %xmm4
movsd (%rsp), %xmm0
subsd %xmm7, %xmm4
movsd %xmm4, (%rbx,%rdx,8)
addsd 0x8(%rsp), %xmm0
addq $0x2, %rbp
cmpq %rbp, %r12
jne 0x123e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: gen2fftorder
unsigned *gen2fftorder(unsigned size) {
    unsigned *offset = (unsigned *)malloc(sizeof(unsigned) * size),
        stride = 1, step;

    memset(offset, 0xff, sizeof(unsigned) * size);
    offset[0] = 0;

    for (step = size >> 1; step > 0; step >>= 1) {
        unsigned base = 0, i;
        for (i = 0; i < size; i += step) {
            if (offset[i] != UINT_MAX) {
                base = offset[i];
            } else {
                offset[i] = base + stride;
            }
        }
        stride <<= 1;
    }

    return offset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x1080
movq %rax, %r14
movq %rax, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x1060
movl $0x0, (%r14)
cmpl $0x2, %ebx
jb 0x1389
movl $0x1, %eax
movl %ebx, %ecx
movl %ebx, %edx
shrl %edx
xorl %esi, %esi
xorl %edi, %edi
movl %esi, %esi
movl (%r14,%rsi,4), %r8d
cmpl $-0x1, %r8d
jne 0x1377
leal (%rdi,%rax), %r8d
movl %r8d, (%r14,%rsi,4)
movl %edi, %r8d
addl %edx, %esi
movl %r8d, %edi
cmpl %ebx, %esi
jb 0x1360
addl %eax, %eax
cmpl $0x3, %ecx
movl %edx, %ecx
ja 0x135a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: dit2fft
void dit2fft(const double *input, double *output, unsigned size, int inverse) {
    unsigned *offset = gen2fftorder(size >> 1),
        stride = 1, i;

    while (size > 2) {
        stride <<= 1;
        size >>= 1;
    }

    for (i = 0; i < stride; i++) {
        radix2fft(&input[offset[i] << 1], &output[(i * 2) << 1], stride);
    }

    free(offset);

    while (stride > 1) {
        stride >>= 1;
        size <<= 1;
        for (i = 0; i < stride; i++) {
            sum2fft(&output[(i * size) << 1], &output[(i * size) << 1], size >> 1, inverse);
        }
    }

    if (inverse) {
        for (i = 0; i < size; i++) {
            output[i << 1] /= (double)size;
            output[(i << 1) + 1] /= (double)size;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %edi
shrl %edi
callq 0x131c
movl $0x1, %r13d
cmpl $0x3, %r15d
jb 0x13da
movl $0x1, %r13d
movl %r15d, %r12d
addl %r13d, %r13d
shrl %r12d
cmpl $0x5, %r15d
movl %r12d, %r15d
ja 0x13c9
jmp 0x13dd
movl %r15d, %r12d
testl %r13d, %r13d
je 0x145f
leal (,%r13,2), %ecx
leal 0x1(,%r13,2), %edx
movl %r13d, %esi
shlq $0x2, %rsi
xorl %edi, %edi
movl (%rax,%rdi), %r8d
addl %r8d, %r8d
leaq (%r14,%r8,8), %r8
movl %edi, %r9d
movsd (%r8), %xmm0
addsd (%r8,%rcx,8), %xmm0
andl $-0x4, %r9d
movsd %xmm0, (%rbx,%r9,8)
movsd 0x8(%r8), %xmm0
addsd (%r8,%rdx,8), %xmm0
movsd %xmm0, 0x8(%rbx,%r9,8)
movsd (%r8), %xmm0
subsd (%r8,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rbx,%r9,8)
movsd 0x8(%r8), %xmm0
subsd (%r8,%rdx,8), %xmm0
movsd %xmm0, 0x18(%rbx,%r9,8)
addq $0x4, %rdi
cmpq %rdi, %rsi
jne 0x13fb
movq %rax, %rdi
callq 0x1030
cmpl $0x2, %r13d
jb 0x14d5
movq %r12, 0x10(%rsp)
movl %r13d, %eax
shrl %r13d
movq %r13, 0x8(%rsp)
movl %eax, 0x4(%rsp)
cmpl $0x2, %eax
jb 0x14c1
movq 0x10(%rsp), %rax
leal (,%rax,4), %r15d
movl %eax, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movl 0x8(%rsp), %r13d
xorl %r12d, %r12d
movl %r12d, %eax
leaq (%rbx,%rax,8), %rdi
movq %rdi, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x11ea
addl %r15d, %r12d
decq %r13
jne 0x14a5
movq 0x10(%rsp), %r12
addl %r12d, %r12d
cmpl $0x4, 0x4(%rsp)
movq 0x8(%rsp), %r13
jae 0x146d
testl %ebp, %ebp
setne %al
testl %r12d, %r12d
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1517
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
addq %rax, %rax
xorl %ecx, %ecx
movl %ecx, %edx
andl $-0x2, %edx
movupd (%rbx,%rdx,8), %xmm1
divpd %xmm0, %xmm1
movupd %xmm1, (%rbx,%rdx,8)
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x14fb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: computeNormalized
void computeNormalized(const double *f, const double *g, double *r) {
    double a1 = (f[1] != 0.0) ? ((f[0] != 0.0) ? atan(f[1] / f[0]) : copysign(M_PI, f[1]) / 2.0) : 0.0;
    if (f[0] < 0.0) {
        a1 = copysign(M_PI, f[1]) + a1;
    }

    double a2 = (g[1] != 0.0) ? ((g[0] != 0.0) ? atan(g[1] / g[0]) : copysign(M_PI, g[1]) / 2.0) : 0.0;
    if (g[0] < 0.0) {
        a2 = copysign(M_PI, g[1]) + a2;
    }

    r[0] = cos(a1 - a2);
    r[1] = sin(a1 - a2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x8(%rdi), %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
xorpd %xmm3, %xmm3
jne 0x1753
jnp 0x178f
movsd (%r15), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x1764
jnp 0x1773
divsd %xmm1, %xmm0
callq 0x1040
xorpd %xmm4, %xmm4
jmp 0x178b
andpd 0x8a5(%rip), %xmm0      # 0x2020
orpd 0x8ad(%rip), %xmm0      # 0x2030
mulsd 0x8b5(%rip), %xmm0      # 0x2040
movapd %xmm0, %xmm3
ucomisd (%r15), %xmm4
jbe 0x17b0
movsd 0x8(%r15), %xmm0
andpd 0x87c(%rip), %xmm0      # 0x2020
orpd 0x884(%rip), %xmm0      # 0x2030
addsd %xmm0, %xmm3
movsd 0x8(%r14), %xmm1
ucomisd %xmm4, %xmm1
xorpd %xmm0, %xmm0
jne 0x17c2
jnp 0x180e
movsd (%r14), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x17d3
jnp 0x17f2
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x1040
xorpd %xmm4, %xmm4
movsd 0x8(%rsp), %xmm3
jmp 0x180e
andpd 0x826(%rip), %xmm1      # 0x2020
orpd 0x82e(%rip), %xmm1      # 0x2030
mulsd 0x836(%rip), %xmm1      # 0x2040
movapd %xmm1, %xmm0
ucomisd (%r14), %xmm4
jbe 0x182f
movsd 0x8(%r14), %xmm1
andpd 0x7fd(%rip), %xmm1      # 0x2020
orpd 0x805(%rip), %xmm1      # 0x2030
addsd %xmm1, %xmm0
subsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x1070
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x1090
movsd %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/markondej[P]phase_correl/phase_correl.c
// Function: main
int main()
{
    unsigned char image1[256 * 128];
    unsigned char image2[256 * 128];

    unsigned i, j;
    int deltax, deltay;

    // Generate pair of images
    for (j = 0; j < 128; j++)
        for (i = 0; i < 256; i++) {
            unsigned offset = i + j * 256;
            if ((i >= 16) && (i < 76) && (j >= 32) && (j < 92))
                image1[offset] = 128;
            else
                image1[offset] = 0;

            if ((i >= 8) && (i < 68) && (j >= 40) && (j < 100))
                image2[offset] = 16;
            else
                image2[offset] = 255;
        }

    computeShift(image1, image2, 256, 128, &deltax, &deltay);

    printf("Calculated shift: [%d, %d]\n", deltax, deltay);

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10010, %rsp          # imm = 0x10010
leaq 0x10(%rsp), %rax
leaq 0x8010(%rsp), %rcx
xorl %edx, %edx
movl $0x100, %esi            # imm = 0x100
leal -0x20(%rdx), %edi
leal -0x28(%rdx), %r8d
movl $0xfffffff8, %r9d       # imm = 0xFFFFFFF8
xorl %r10d, %r10d
cmpl $0x3c, %r8d
setae %r11b
cmpl $0x3c, %edi
setb %bl
leal -0x8(%r9), %ebp
cmpl $0x3c, %ebp
setb %bpl
andb %bl, %bpl
shlb $0x7, %bpl
movb %bpl, (%rcx,%r10)
cmpl $0x3c, %r9d
setae %bl
orb %r11b, %bl
negb %bl
orb $0x10, %bl
movb %bl, (%rax,%r10)
incq %r10
incl %r9d
cmpq $0x100, %r10            # imm = 0x100
jne 0x1b2f
incq %rdx
addq %rsi, %rax
addq %rsi, %rcx
cmpq $0x80, %rdx
jne 0x1b1f
leaq 0x8010(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rbx
leaq 0x8(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movl $0x80, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x1860
movl (%rbx), %esi
movl (%r14), %edx
leaq 0x489(%rip), %rdi       # 0x2048
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x10010, %rsp          # imm = 0x10010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::operator<<(socket_io::socket_view&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto operator<<(socket_view& dst, std::string const& to_send) -> socket_view&
{
    // Prepare data to send
    std::string::size_type const length = to_send.length();
    if (length > std::numeric_limits<uint32_t>::max())
	throw std::invalid_argument{"Input message is too long"};
    uint32_t with_byte_order = htonl(static_cast<uint32_t>(length));
    
    char buffer[length + 1];
    if (snprintf(buffer, length + 1, "%s", to_send.c_str()) < 0)
	throw std::invalid_argument{"Input message is wrong: " +
		                    get_errno_as_string()};
    
    // Send the data
    send(dst.get_native_handle(), static_cast<void*>(&with_byte_order),
	 sizeof(uint32_t));
    send(dst.get_native_handle(), static_cast<void*>(&buffer), length);

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq 0x8(%rsi), %r14
movq %r14, %rax
shrq $0x20, %rax
jne 0x8c66
movq %rdi, %rbx
movq %rsp, %r12
movl %r14d, %eax
bswapl %eax
movl %eax, -0x24(%rbp)
leaq 0x1(%r14), %rax
movq %rsp, %r15
leaq 0x10(%r14), %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
movq (%rsi), %rcx
leaq 0x5405(%rip), %rdx      # 0xe01a
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x8870
testl %eax, %eax
js 0x8c98
movq %rbx, %rdi
callq 0x8420
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
movl %eax, %edi
callq 0x8d49
movq %rbx, %rdi
callq 0x8420
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8d49
movq %r12, %rsp
movq %rbx, %rax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x5386(%rip), %rsi      # 0xe000
movq %rax, %rdi
callq 0x8a00
movq 0xa32f(%rip), %rsi      # 0x12fb8
movq 0xa308(%rip), %rdx      # 0x12f98
movq %rbx, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x8340
leaq 0x5368(%rip), %rsi      # 0xe01d
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x88e0
movb $0x1, %r15b
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x8920
xorl %r15d, %r15d
movq 0xa2dd(%rip), %rsi      # 0x12fb8
movq 0xa2b6(%rip), %rdx      # 0x12f98
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d0e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8d0e
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d2f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8d2f
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
jne 0x8d39
jmp 0x8d41
movq %rax, %r14
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::send(int, void const*, unsigned long)
static inline auto send(int sockfd, void const* buf, size_t len) -> void
{
    int error_code = ::send(sockfd, buf, len, MSG_NOSIGNAL);
    if (error_code == -1 && errno == EPIPE)
	throw std::system_error{std::make_error_code(std::errc::broken_pipe)};
    else if (error_code == -1)    
	throw std::runtime_error{"An error occured while sending the data: " +
		                 get_errno_as_string()};
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x4000, %ecx           # imm = 0x4000
callq 0x8230
cmpl $-0x1, %eax
je 0x8d69
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x8030
cmpl $0x20, (%rax)
jne 0x8dab
movl $0x20, %edi
callq 0x8220
movq %rax, %rbx
callq 0x8240
movq %rbx, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x8300
movq 0xa184(%rip), %rsi      # 0x12f20
movq 0xa19d(%rip), %rdx      # 0x12f40
movq %rbx, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8340
leaq 0x526f(%rip), %rsi      # 0xe036
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0xa203(%rip), %rsi      # 0x12ff0
movq 0xa144(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e22
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8e22
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e45
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8e45
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x8e4f
jmp 0x8e57
movq %rax, %r14
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::operator>>(socket_io::socket_view&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
auto operator>>(socket_view& src, std::string& buffer) -> socket_view&
{
    uint32_t with_byte_order;
    recv(src.get_native_handle(), static_cast<void*>(&with_byte_order),
	 sizeof(uint32_t));

    // No error should occur as the data length sent was of size_type
    std::string::size_type const length = ntohl(with_byte_order);

    char buf[length + 1];
    recv(src.get_native_handle(), static_cast<void*>(&buf), length);
    buf[length] = '\0';

    buffer = std::string{buf};
    return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
callq 0x8420
leaq -0x34(%rbp), %r15
movl $0x4, %edx
movl %eax, %edi
movq %r15, %rsi
callq 0x8f22
movq %rsp, %r13
movl (%r15), %r12d
bswapl %r12d
movq %rsp, %r15
leaq 0x10(%r12), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %rbx, %rdi
callq 0x8420
movl %eax, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8f22
movb $0x0, (%r12,%r15)
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq %r15, %rdi
callq 0x81d0
leaq (%rax,%r15), %rdx
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x81a0
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x85e0
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x8f0d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x84c0
movq %r13, %rsp
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::recv(int, void*, unsigned long)
static inline auto recv(int sockfd, void* buf, size_t len) -> int
{
    ssize_t error_code = ::recv(sockfd, buf, len, 0);
    if (error_code == 0)
	throw std::system_error{std::make_error_code(std::errc::broken_pipe)};
    if (error_code == -1)
	throw std::runtime_error{"An error occured while reading the data: " +
		                 get_errno_as_string()};
    return error_code;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorl %ecx, %ecx
callq 0x8150
cmpq $-0x1, %rax
je 0x8f45
testq %rax, %rax
je 0x8f96
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8340
leaq 0x50ff(%rip), %rsi      # 0xe060
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0xa069(%rip), %rsi      # 0x12ff0
movq 0x9faa(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movl $0x20, %edi
callq 0x8220
movq %rax, %rbx
callq 0x8240
movq %rbx, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x8300
movq 0x9f61(%rip), %rsi      # 0x12f20
movq 0x9f7a(%rip), %rdx      # 0x12f40
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ff4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8ff4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x901c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x901c
movq %rax, %r14
jmp 0x9021
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9029
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::bind(socket_io::socket const&, boost::variant<socket_io::socket_address<sockaddr_in>, socket_io::socket_address<sockaddr_in6>> const&)
auto bind(socket const& unbound, ip_socket_address const& to_bind) -> void
{
    bool is_ipv4 = to_bind.type() == typeid(ipv4_socket_address);
    auto ip_version = unbound.get_ip_protocol();

    if ((is_ipv4 && ip_version == ip_protocol::IPv6) ||
	(!is_ipv4 && ip_version == ip_protocol::IPv4))
	throw std::logic_error{"Socket and address have different protocols"};
    
    if (is_ipv4)
    {
	auto tmp_to_bind = boost::get<ipv4_socket_address>(to_bind);	
	sockaddr_in addr_in = tmp_to_bind.get_native_handle();
	socket_io::bind_wrapper(unbound, reinterpret_cast<sockaddr*>(&addr_in),
				sizeof(sockaddr_in));
	
    }
    else
    {
	auto tmp_to_bind = boost::get<ipv6_socket_address>(to_bind);	
	sockaddr_in6 addr_in6 = tmp_to_bind.get_native_handle();
	socket_io::bind_wrapper(unbound, reinterpret_cast<sockaddr*>(&addr_in6),
				sizeof(sockaddr_in6));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8860
movq 0x8(%rax), %rdi
cmpq 0x9d39(%rip), %rdi      # 0x12f90
je 0x9262
cmpb $0x2a, (%rdi)
jne 0x9266
xorl %eax, %eax
jmp 0x9277
movb $0x1, %al
jmp 0x9277
movq 0x9d23(%rip), %rsi      # 0x12f90
callq 0x8710
testl %eax, %eax
sete %al
movzbl %al, %ecx
leal 0x2(,%rcx,8), %ecx
cmpl %ecx, 0x4(%rbx)
je 0x9304
testb %al, %al
je 0x92b1
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8950
testq %rax, %rax
je 0x9336
movups (%rax), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
movl $0x10, %edx
jmp 0x92f7
movq %rsp, %rsi
movq %r14, %rdi
callq 0x83b0
testq %rax, %rax
je 0x934c
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups 0xc(%rsp), %xmm1
leaq 0x30(%rsp), %rsi
movups %xmm1, 0xc(%rsi)
movaps %xmm0, (%rsi)
movq %rbx, %rdi
movl $0x1c, %edx
callq 0x938e
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x4eb8(%rip), %rsi      # 0xe1d0
movq %rax, %rdi
callq 0x8790
movq 0x9c89(%rip), %rsi      # 0x12fb0
movq 0x9c2a(%rip), %rdx      # 0x12f58
movq %r14, %rdi
callq 0x8900
movq 0x9bd3(%rip), %rax      # 0x12f10
addq $0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x84b0
movq 0x9bbd(%rip), %rax      # 0x12f10
addq $0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x84b0
jmp 0x9364
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89c0
jmp 0x9386
jmp 0x9373
movq %rax, %rdi
callq 0x95b2
movq %rax, %rbx
movq %r14, %rdi
callq 0x8330
movq %rbx, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::accept(socket_io::socket const&)
auto accept(socket const& server) -> socket
{
    int sockfd = ::accept(server.get_native_handle(), nullptr, nullptr);
    if (sockfd == -1)
	throw std::runtime_error{"An error occured while accepting a client: " +
				 get_errno_as_string()};
    return socket{sockfd, server.get_ip_protocol()};
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8140
cmpl $-0x1, %eax
je 0x9497
movl 0x4(%r14), %ecx
movq %rsp, %rdx
movl %ecx, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x8590
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8340
leaq 0x4d47(%rip), %rsi      # 0xe1fc
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x88e0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x9b17(%rip), %rsi      # 0x12ff0
movq 0x9a58(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x950e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x950e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9531
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x9531
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x953e
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::is_socket_handle(int, socket_io::ip_protocol const&)
auto is_socket_handle(int const handle, ip_protocol const& ip_version) noexcept
    -> bool
{
    sockaddr addr;
    socklen_t addrlen = sizeof(sockaddr);

    if (getsockname(handle, &addr, &addrlen) == -1)
	return false;

    if (addr.sa_family != AF_INET && addr.sa_family != AF_INET6)
	return false;

    if (addr.sa_family == AF_INET && ip_version == ip_protocol::IPv6)
	return false;
    if (addr.sa_family == AF_INET6 && ip_version == ip_protocol::IPv4)
	return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
leaq 0x10(%rsp), %rsi
callq 0x8430
cmpl $-0x1, %eax
je 0x9599
movzwl 0x10(%rsp), %eax
movl %eax, %ecx
andl $-0x9, %ecx
cmpw $0x2, %cx
jne 0x9599
cmpw $0x2, %ax
sete %dl
movl (%rbx), %ecx
cmpl $0xa, %ecx
sete %sil
testb %sil, %dl
je 0x95a1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
cmpw $0xa, %ax
setne %dl
cmpl $0x2, %ecx
setne %al
orb %dl, %al
jmp 0x959b
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/client.cpp
// Function: socket_io::client::~client()
client::~client() noexcept
{
    try
    {
	main_socket.make_view() << std::to_string(id);
    }
    catch (...)
    { /* Ignore the exception */ }	
    shutdown(main_socket);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x80d0
movq %rax, (%rsp)
movl 0x38(%rbx), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x9f63
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x9f5a
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x9f60
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x9f63
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x9f27
addl $-0x3, %r15d
jmp 0x9f63
addl $-0x2, %r15d
jmp 0x9f63
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x8580
leaq 0x8(%rsp), %r12
addq (%r12), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x8750
movq %rsp, %rdi
movq %r12, %rsi
callq 0x8a60
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9fbb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8640
leaq 0x8(%rbx), %rdi
callq 0x87a0
movq %rbx, %rdi
callq 0x8510
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa002
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa002
movq %rax, %r14
movq %r14, %rdi
callq 0x81c0
callq 0x88c0
jmp 0x9fbb
movq %rax, %rdi
callq 0x95b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/socket.cpp
// Function: socket_io::socket::socket(socket_io::ip_protocol const&)
socket::socket(ip_protocol const& ip_version)
    : ip_version{ip_version}
{
    handle = ::socket(static_cast<int>(ip_version), SOCK_STREAM, 0);
    if (handle == -1)
	throw std::runtime_error("An error occured while creating a socket: " +
				 get_errno_as_string());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, 0x4(%rdi)
movl (%rsi), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80f0
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xa512
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8340
leaq 0x410b(%rip), %rsi      # 0xe639
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x8a9c(%rip), %rsi      # 0x12ff0
movq 0x89dd(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa589
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa589
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5ac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa5ac
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa5b9
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/socket.cpp
// Function: socket_io::socket::operator=(socket_io::socket&&)
auto socket::operator=(socket&& other) noexcept -> socket&
{
    if (this == &other)
	return *this;
    handle = other.handle;
    ip_version = other.ip_version;
    other.handle = SOCKFD_AFTER_MOVE;
    return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0xa66a
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, (%rsi)
retq
nop