LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Windfisch[P]production-flow/factory.cpp
// Function: pop_root_node(std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>, std::allocator<std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>>>> const&)
static size_t pop_root_node(vector<size_t>& relevant_facilities, const vector< unordered_set<size_t> >& incident_edges)
{
	for (size_t& facility_id : relevant_facilities)
		if (incident_edges[facility_id].empty())
		{
			size_t result = facility_id;

			facility_id = relevant_facilities.back();
			relevant_facilities.pop_back();

			return result;
		}

	return INVALID_INDEX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7c60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7ab0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb140
testb $0x1, %al
jne 0x8a55
jmp 0x8abe
leaq -0x28(%rbp), %rdi
callq 0x7f80
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0xb180
movq %rax, %rdi
callq 0xa4d0
testb $0x1, %al
jne 0x8a80
jmp 0x8ab1
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7ae0
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xb1a0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8ac6
jmp 0x8ab3
leaq -0x28(%rbp), %rdi
callq 0xb1d0
jmp 0x8a42
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::Node::incoming() const
int FlowGraph::Node::incoming() const
{
	int result = 0;

	for (Edge* edge : incoming_edges)
		result += edge->actual_flow;

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14830
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14860
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x12fbc
jmp 0x12fe4
leaq -0x20(%rbp), %rdi
callq 0x148d0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x148f0
jmp 0x12fa9
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0x10(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11fe0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14b90
testb $0x1, %al
jne 0x13629
jmp 0x1364a
leaq -0x20(%rbp), %rdi
callq 0x12080
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x13030
leaq -0x20(%rbp), %rdi
callq 0x14bd0
jmp 0x13616
movq -0xb0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x11fe0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x11d00
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14b90
testb $0x1, %al
jne 0x13682
jmp 0x136a3
leaq -0x40(%rbp), %rdi
callq 0x12080
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x13350
leaq -0x40(%rbp), %rdi
callq 0x14bd0
jmp 0x1366f
movq -0xb0(%rbp), %rax
movb $0x1, -0x9(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x11fe0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x11d00
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x14b90
testb $0x1, %al
jne 0x136df
jmp 0x13707
leaq -0x60(%rbp), %rdi
callq 0x12080
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x136fa
movb $0x0, -0x9(%rbp)
jmp 0x136fc
leaq -0x60(%rbp), %rdi
callq 0x14bd0
jmp 0x136cc
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x135f1
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3500
movq -0xb8(%rbp), %rdx
leaq 0x11e82(%rip), %rsi     # 0x255c0
leaq -0x90(%rbp), %rdi
callq 0x5630
jmp 0x1374c
movq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x137d0
jmp 0x13761
leaq -0x90(%rbp), %rdi
callq 0x3588
leaq -0x91(%rbp), %rdi
callq 0x3310
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x137b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3588
leaq -0x91(%rbp), %rdi
callq 0x3310
movq -0xa0(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::is_valid() const
bool FlowGraph::is_valid() const
{
	for (const auto& node : nodes)
		if (node.incoming() < -node.max_production)
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14bf0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14c20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14c50
testb $0x1, %al
jne 0x13b31
jmp 0x13b66
leaq -0x20(%rbp), %rdi
callq 0x14c90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x12f70
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
cmpl %ecx, %eax
jge 0x13b59
movb $0x0, -0x1(%rbp)
jmp 0x13b6a
jmp 0x13b5b
leaq -0x20(%rbp), %rdi
callq 0x14cb0
jmp 0x13b1e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x11260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x146b7
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14f90
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14830
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14860
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x14673
jmp 0x146a4
leaq -0x28(%rbp), %rdi
callq 0x148d0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x14697
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x14699
leaq -0x28(%rbp), %rdi
callq 0x148f0
jmp 0x14660
jmp 0x146a6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14610
movl $0x10, %edi
callq 0x3170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x10f34(%rip), %rsi     # 0x25606
callq 0x3120
jmp 0x146d9
movq -0x60(%rbp), %rdi
movq 0x2490c(%rip), %rsi     # 0x38ff0
movq 0x248d5(%rip), %rdx     # 0x38fc0
callq 0x34c0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3230
movq -0x40(%rbp), %rdi
callq 0x34f0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x11260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x147d7
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14f90
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14830
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14860
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x14793
jmp 0x147c4
leaq -0x28(%rbp), %rdi
callq 0x148d0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x147b7
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x147b9
leaq -0x28(%rbp), %rdi
callq 0x148f0
jmp 0x14780
jmp 0x147c6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14730
movl $0x10, %edi
callq 0x3170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x10e14(%rip), %rsi     # 0x25606
callq 0x3120
jmp 0x147f9
movq -0x60(%rbp), %rdi
movq 0x247ec(%rip), %rsi     # 0x38ff0
movq 0x247b5(%rip), %rdx     # 0x38fc0
callq 0x34c0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3230
movq -0x40(%rbp), %rdi
callq 0x34f0
nop
// File: Windfisch[P]production-flow/./factory.hpp
// Function: Factory::Facility::Facility(std::vector<Factory::FacilityConfiguration, std::allocator<Factory::FacilityConfiguration>>)
Facility(std::vector<FacilityConfiguration> upgrade_plan_) :
			upgrade_plan(std::move(upgrade_plan_))
		{
			for (const auto& conf : upgrade_plan)
				for (const auto& itemprod : conf.production_or_consumption)
					if (itemprod.second != 0)
						items.insert(itemprod.first);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x21460
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x21490
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x204a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x214b0
testb $0x1, %al
jne 0x20f69
jmp 0x21038
leaq -0x20(%rbp), %rdi
callq 0x214f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x21510
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xaa30
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xaa00
testb $0x1, %al
jne 0x20fab
jmp 0x21028
leaq -0x40(%rbp), %rdi
callq 0x21540
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x21018
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq -0x50(%rbp), %rsi
callq 0x9ed0
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x20fe2
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
jmp 0x21018
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x6bb0
movq -0x78(%rbp), %rdi
callq 0x6bd0
jmp 0x21041
jmp 0x2101a
leaq -0x40(%rbp), %rdi
callq 0x21570
jmp 0x20f98
jmp 0x2102a
leaq -0x20(%rbp), %rdi
callq 0x215a0
jmp 0x20f53
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x24d0
leaq -0x70(%rbp), %rdi
callq 0x24f0
movq 0x5c05(%rip), %rdi      # 0x7fe0
leaq -0x70(%rbp), %rsi
callq 0x40d0
movq %rax, -0x90(%rbp)
jmp 0x23ed
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2170
movb %al, -0x91(%rbp)
jmp 0x240b
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2417
jmp 0x245d
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2530
movq %rax, -0xa0(%rbp)
jmp 0x242d
movq -0xa0(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x23d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2580
leaq -0x40(%rbp), %rdi
callq 0x25a0
jmp 0x24b8
leaq -0x40(%rbp), %rdi
callq 0x2560
movq %rax, %rsi
movq 0x5b60(%rip), %rdi      # 0x7fd0
callq 0x2050
movq %rax, -0xa8(%rbp)
jmp 0x247e
movq -0xa8(%rbp), %rdi
movq 0x5b34(%rip), %rsi      # 0x7fc0
callq 0x2150
jmp 0x2493
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2580
leaq -0x40(%rbp), %rdi
callq 0x25a0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
addsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
addsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
subsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
subsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %edx
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x1070
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movl 0x24(%rsp), %eax
shrl %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jbe 0x15be
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x15a8
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x1584
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
jmp 0x1598
movl 0xc(%rsp), %edx
addl 0x14(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x159a
movl 0x10(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x1559
movl 0x14(%rsp), %eax
shll %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
shrl %eax
movl %eax, 0x10(%rsp)
jmp 0x1542
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl 0x14(%rsp), %edi
shrl %edi
callq 0x14f0
movq %rax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
cmpl $0x2, 0x14(%rsp)
jbe 0x161b
movl 0x4(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
shrl %eax
movl %eax, 0x14(%rsp)
jmp 0x15fe
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x166f
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
movl (%rax,%rcx,4), %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl (%rsp), %eax
shll %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movl 0x4(%rsp), %edx
callq 0x11c0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1622
movq 0x8(%rsp), %rdi
callq 0x1030
cmpl $0x1, 0x4(%rsp)
jbe 0x16f0
movl 0x4(%rsp), %eax
shrl %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
shll %eax
movl %eax, 0x14(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x16ee
movq 0x18(%rsp), %rdi
movl (%rsp), %eax
imull 0x14(%rsp), %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl (%rsp), %eax
imull 0x14(%rsp), %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movl 0x14(%rsp), %edx
shrl %edx
movl 0x10(%rsp), %ecx
callq 0x1270
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x169b
jmp 0x1679
cmpl $0x0, 0x10(%rsp)
je 0x175b
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x1759
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x18(%rsp), %rax
movl (%rsp), %ecx
addl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm1
movq 0x18(%rsp), %rax
movl (%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x16fe
jmp 0x175b
addq $0x28, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a9a
jp 0x1a9a
jmp 0x1b10
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1ab0
jp 0x1ab0
jmp 0x1ad0
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd (%rax), %xmm0
callq 0x1040
movsd %xmm0, 0x18(%rsp)
jmp 0x1b02
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x153f(%rip), %xmm1     # 0x3020
pand %xmm1, %xmm0
movaps 0x1544(%rip), %xmm1     # 0x3030
por %xmm1, %xmm0
movsd 0x1548(%rip), %xmm1     # 0x3040
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1b1b
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1b1b
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1b61
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x14da(%rip), %xmm1     # 0x3020
pand %xmm1, %xmm0
movaps 0x14df(%rip), %xmm1     # 0x3030
por %xmm1, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1b78
jp 0x1b78
jmp 0x1bed
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1b8e
jp 0x1b8e
jmp 0x1bae
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x38(%rsp), %rax
divsd (%rax), %xmm0
callq 0x1040
movsd %xmm0, 0x8(%rsp)
jmp 0x1be0
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x1461(%rip), %xmm1     # 0x3020
pand %xmm1, %xmm0
movaps 0x1466(%rip), %xmm1     # 0x3030
por %xmm1, %xmm0
movsd 0x146a(%rip), %xmm1     # 0x3040
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x1bf7
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x1bf7
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1c3c
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x13ff(%rip), %xmm1     # 0x3020
pand %xmm1, %xmm0
movaps 0x1404(%rip), %xmm1     # 0x3030
por %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
callq 0x1080
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
callq 0x10a0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x8(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x10028, %rsp          # imm = 0x10028
movl $0x0, 0x10024(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x80, 0x18(%rsp)
jae 0x20e9
movl $0x0, 0x1c(%rsp)
cmpl $0x100, 0x1c(%rsp)      # imm = 0x100
jae 0x20d7
movl 0x1c(%rsp), %eax
movl 0x18(%rsp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
cmpl $0x10, 0x1c(%rsp)
jb 0x2089
cmpl $0x4c, 0x1c(%rsp)
jae 0x2089
cmpl $0x20, 0x18(%rsp)
jb 0x2089
cmpl $0x5c, 0x18(%rsp)
jae 0x2089
movl 0xc(%rsp), %eax
movb $-0x80, 0x8020(%rsp,%rax)
jmp 0x2095
movl 0xc(%rsp), %eax
movb $0x0, 0x8020(%rsp,%rax)
cmpl $0x8, 0x1c(%rsp)
jb 0x20bc
cmpl $0x44, 0x1c(%rsp)
jae 0x20bc
cmpl $0x28, 0x18(%rsp)
jb 0x20bc
cmpl $0x64, 0x18(%rsp)
jae 0x20bc
movl 0xc(%rsp), %eax
movb $0x10, 0x20(%rsp,%rax)
jmp 0x20c5
movl 0xc(%rsp), %eax
movb $-0x1, 0x20(%rsp,%rax)
jmp 0x20c7
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2040
jmp 0x20d9
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x202a
leaq 0x8020(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
movl $0x80, %ecx
leaq 0x14(%rsp), %r8
leaq 0x10(%rsp), %r9
callq 0x1c80
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0xf2a(%rip), %rdi       # 0x3048
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x10028, %rsp          # imm = 0x10028
retq
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x1ea90
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x211c3
callq 0x1e0e0
cmpl $0x20, (%rax)
jne 0x211c3
movl $0x20, %edi
callq 0x1ea70
movq %rax, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movl $0x20, %edi
callq 0x1e970
movq -0x90(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1eee0
jmp 0x2118c
movq -0x98(%rbp), %rdi
movq 0x19d6e(%rip), %rsi     # 0x3af08
movq 0x19d8f(%rip), %rdx     # 0x3af30
callq 0x20690
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1efc0
jmp 0x21299
cmpl $-0x1, -0x1c(%rbp)
jne 0x2128e
movb $0x1, -0x81(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1f040
jmp 0x211f0
leaq 0xfe3f(%rip), %rsi      # 0x31036
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x20610
jmp 0x21206
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x204c0
jmp 0x21218
movq -0xa0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
movq 0x19dc3(%rip), %rsi     # 0x3aff0
movq 0x19cf4(%rip), %rdx     # 0x3af28
callq 0x20690
jmp 0x212a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21275
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2126c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x80(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x81(%rbp)
jne 0x21280
jmp 0x2128c
movq -0xa0(%rbp), %rdi
callq 0x1efc0
jmp 0x21299
jmp 0x21290
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f480
movl %eax, %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x213e0
movl -0x14(%rbp), %edi
callq 0x1fc70
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq %rdx, %rax
incq %rax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x78(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f480
movq -0x78(%rbp), %rsi
movl %eax, %edi
movq -0x20(%rbp), %rdx
callq 0x213e0
movq -0x78(%rbp), %rcx
movq -0x20(%rbp), %rax
movb $0x0, (%rax,%rcx)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x20850
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x20640
jmp 0x21388
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1fbb0
leaq -0x50(%rbp), %rdi
callq 0x1ed60
leaq -0x51(%rbp), %rdi
callq 0x1f860
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x1f860
movq -0x60(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1e6f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x21488
movl $0x20, %edi
callq 0x1ea70
movq %rax, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movl $0x20, %edi
callq 0x1e970
movq -0x90(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1eee0
jmp 0x21451
movq -0x98(%rbp), %rdi
movq 0x19aa9(%rip), %rsi     # 0x3af08
movq 0x19aca(%rip), %rdx     # 0x3af30
callq 0x20690
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1efc0
jmp 0x21561
cmpq $-0x1, -0x20(%rbp)
jne 0x21554
movb $0x1, -0x81(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1f040
jmp 0x214b6
leaq 0xfba3(%rip), %rsi      # 0x31060
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x20610
jmp 0x214cc
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x204c0
jmp 0x214de
movq -0xa0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
movq 0x19afd(%rip), %rsi     # 0x3aff0
movq 0x19a2e(%rip), %rdx     # 0x3af28
callq 0x20690
jmp 0x2156a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2153b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x80(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x81(%rbp)
jne 0x21546
jmp 0x21552
movq -0xa0(%rbp), %rdi
callq 0x1efc0
jmp 0x21561
movq -0x20(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x20840
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e080
movq %rax, %rdi
movq 0x19462(%rip), %rsi     # 0x3afd8
callq 0x1eec0
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x200d0
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x21b98
cmpl $0xa, -0x18(%rbp)
je 0x21ba4
testb $0x1, -0x11(%rbp)
jne 0x21c00
cmpl $0x2, -0x18(%rbp)
jne 0x21c00
movl $0x10, %edi
callq 0x1ea70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0xf60e(%rip), %rsi      # 0x311d0
callq 0x200f0
jmp 0x21bc9
movq -0xa0(%rbp), %rdi
movq 0x193d9(%rip), %rsi     # 0x3afb0
movq 0x1937a(%rip), %rdx     # 0x3af58
callq 0x20690
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1efc0
jmp 0x21c93
testb $0x1, -0x11(%rbp)
je 0x21c4b
movq -0x10(%rbp), %rdi
callq 0x1ed70
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1e520
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x10, %edx
callq 0x21ca0
jmp 0x21c8a
movq -0x10(%rbp), %rdi
callq 0x20980
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movl $0x28, %edx
callq 0x1f290
leaq -0x94(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1fab0
movq -0x8(%rbp), %rdi
leaq -0x94(%rbp), %rsi
movl $0x1c, %edx
callq 0x21ca0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e990
movl %eax, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1e6a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x21e8d
movb $0x1, -0x65(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1f040
jmp 0x21df2
leaq 0xf403(%rip), %rsi      # 0x311fc
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x20610
jmp 0x21e08
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x204c0
jmp 0x21e1a
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
movq 0x191c4(%rip), %rsi     # 0x3aff0
movq 0x190f5(%rip), %rdx     # 0x3af28
callq 0x20690
jmp 0x21ecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x21e77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x21e6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1ed60
leaq -0x58(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x65(%rbp)
jne 0x21e7f
jmp 0x21e8b
movq -0x88(%rbp), %rdi
callq 0x1efc0
jmp 0x21ec2
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x200d0
movq -0x80(%rbp), %rdi
movl -0x8c(%rbp), %esi
movl %eax, -0x6c(%rbp)
leaq -0x6c(%rbp), %rdx
callq 0x1fae0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x20840
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, -0x24(%rbp)
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x1f540
cmpl $-0x1, %eax
jne 0x21f31
movb $0x0, -0x1(%rbp)
jmp 0x21f7d
movzwl -0x20(%rbp), %eax
cmpl $0x2, %eax
je 0x21f49
movzwl -0x20(%rbp), %eax
cmpl $0xa, %eax
je 0x21f49
movb $0x0, -0x1(%rbp)
jmp 0x21f7d
movzwl -0x20(%rbp), %eax
cmpl $0x2, %eax
jne 0x21f61
movq -0x10(%rbp), %rax
cmpl $0xa, (%rax)
jne 0x21f61
movb $0x0, -0x1(%rbp)
jmp 0x21f7d
movzwl -0x20(%rbp), %eax
cmpl $0xa, %eax
jne 0x21f79
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x21f79
movb $0x0, -0x1(%rbp)
jmp 0x21f7d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e3c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x10(%rbp)
movl 0x38(%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x1fd20
jmp 0x24592
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20d90
jmp 0x245a1
leaq -0x30(%rbp), %rdi
callq 0x1ed60
jmp 0x245e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x245cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ed60
movq -0x38(%rbp), %rdi
callq 0x1e8b0
callq 0x20520
jmp 0x245df
jmp 0x245e1
movq -0x48(%rbp), %rdi
callq 0x1fcd0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x20700
movq -0x48(%rbp), %rdi
callq 0x1f7d0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x21b10
nop
// File: dak98[P]SocketIO/include/utils.hpp
// Function: int string_to_integer<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto string_to_integer(std::string const& str) -> integer
{
    static_assert(std::is_integral<integer>::value);
    const long long converted_integer = std::stoi(str, 0, 10);
    if (converted_integer < std::numeric_limits<integer>::min() ||
	converted_integer > std::numeric_limits<integer>::max())
	throw std::out_of_range{"Input value out of range"};
    return static_cast<integer>(converted_integer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x20c70
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1ef50
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x24cda
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1f1c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x24d2a
movl $0x10, %edi
callq 0x1ea70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xc87e(%rip), %rsi      # 0x31573
callq 0x1e1e0
jmp 0x24cfc
movq -0x38(%rbp), %rdi
movq 0x16299(%rip), %rsi     # 0x3afa0
movq 0x1627a(%rip), %rdx     # 0x3af88
callq 0x20690
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1efc0
jmp 0x24d34
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1e480
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
jne 0x25be0
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1f040
jmp 0x25b51
leaq 0xbb11(%rip), %rsi      # 0x31669
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x20610
jmp 0x25b67
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x204c0
jmp 0x25b76
movq -0x70(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x1546b(%rip), %rsi     # 0x3aff0
movq 0x1539c(%rip), %rdx     # 0x3af28
callq 0x20690
jmp 0x25bef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25bc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ed60
leaq -0x50(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x5d(%rbp)
jne 0x25bd5
jmp 0x25bde
movq -0x70(%rbp), %rdi
callq 0x1efc0
jmp 0x25be6
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x20840
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x25d24
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25d48
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movl $0x1, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: dak98[P]SocketIO/src/socket.cpp
// Function: socket_io::socket::to_string[abi:cxx11]() const
auto socket::to_string() const -> std::string
{
    std::string ip_version_str;
    if (ip_version == ip_protocol::IPv4)
        ip_version_str = "IPv4";
    else
	ip_version_str = "IPv6";       
    return "(SOCK_STREAM, " + ip_version_str + ")";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fed0
movq -0x68(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x25dab
leaq 0xb91e(%rip), %rsi      # 0x316ae
leaq -0x30(%rbp), %rdi
callq 0x1fe30
jmp 0x25d9b
jmp 0x25dbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x25e1f
leaq 0xb901(%rip), %rsi      # 0x316b3
leaq -0x30(%rbp), %rdi
callq 0x1fe30
jmp 0x25dbd
jmp 0x25dbf
leaq 0xb8f2(%rip), %rsi      # 0x316b8
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1f3e0
jmp 0x25dd5
movq -0x78(%rbp), %rdi
leaq 0xb8e7(%rip), %rdx      # 0x316c7
leaq -0x60(%rbp), %rsi
callq 0x1e3d0
jmp 0x25deb
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x30(%rbp), %rdi
callq 0x1ed60
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x30(%rbp), %rdi
callq 0x1ed60
movq -0x38(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::accept_clients()
auto server::accept_clients() -> void
{
    for (;;)
    {
	try
	{
	    socket client = accept(main_socket);
	    socket_view view = client.make_view();

	    epoll_handle.add(view, EPOLLIN);
	    
	    int const id = connected.add(std::move(client));
	    view << std::to_string(id);
	}
	catch (...)
	{ /* Ignore the exceptions */ }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
addq $0xc, %rsi
leaq -0x10(%rbp), %rdi
callq 0x1ff80
jmp 0x25fd7
leaq -0x10(%rbp), %rdi
callq 0x1e3c0
movq -0x50(%rbp), %rdi
movq %rax, -0x24(%rbp)
addq $0x48, %rdi
leaq -0x24(%rbp), %rsi
movl $0x1, %edx
callq 0x205a0
jmp 0x25ffc
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
leaq -0x10(%rbp), %rsi
callq 0x20010
movl %eax, -0x54(%rbp)
jmp 0x26012
movl -0x54(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x1fd20
jmp 0x26026
leaq -0x24(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1eac0
jmp 0x26035
leaq -0x48(%rbp), %rdi
callq 0x1ed60
leaq -0x10(%rbp), %rdi
callq 0x1f7d0
jmp 0x26091
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x26083
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2607a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1ed60
leaq -0x10(%rbp), %rdi
callq 0x1f7d0
movq -0x18(%rbp), %rdi
callq 0x1e8b0
callq 0x20520
jmp 0x25fc4
nopw %cs:(%rax,%rax)
// File: dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::~server()
server::~server() noexcept
{
    using client_cell = registry_of_clients::client_cell;
    std::vector<client_cell> sockets_for_clients = connected.get_clients();
    for (auto& [id, socket] : sockets_for_clients)
    {
	socket_view view = socket.make_view();
	
	view << "EXIT";
	epoll_handle.remove(view);
	shutdown(socket);
    }
    shutdown(main_socket);
    pthread_cancel(accept_clients_tid.native_handle());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
addq $0x68, %rsi
leaq -0x20(%rbp), %rdi
callq 0x1f5c0
jmp 0x264f9
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1e8f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1f770
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1e460
testb $0x1, %al
jne 0x26531
jmp 0x265dc
leaq -0x30(%rbp), %rdi
callq 0x1fb80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1f4c0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1e330
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1e3c0
movq %rax, -0x58(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x20850
movq -0x90(%rbp), %rdx
leaq 0xb277(%rip), %rsi      # 0x317fa
leaq -0x78(%rbp), %rdi
callq 0x20640
jmp 0x2658e
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1eac0
jmp 0x2659d
leaq -0x78(%rbp), %rdi
callq 0x1ed60
leaq -0x79(%rbp), %rdi
callq 0x1f860
movq -0x88(%rbp), %rdi
addq $0x48, %rdi
leaq -0x58(%rbp), %rsi
callq 0x1f760
jmp 0x265c5
movq -0x50(%rbp), %rdi
callq 0x1fcd0
leaq -0x30(%rbp), %rdi
callq 0x1e910
jmp 0x2651b
movq -0x88(%rbp), %rdi
addq $0xc, %rdi
callq 0x1fcd0
movq -0x88(%rbp), %rdi
callq 0x1e350
movq %rax, -0x98(%rbp)
jmp 0x26601
movq -0x98(%rbp), %rdi
callq 0x1ff60
jmp 0x2660f
leaq -0x20(%rbp), %rdi
callq 0x1e3b0
movq -0x88(%rbp), %rdi
addq $0x68, %rdi
callq 0x1e5f0
movq -0x88(%rbp), %rdi
addq $0x48, %rdi
callq 0x1fb00
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
callq 0x20700
movq -0x88(%rbp), %rdi
addq $0xc, %rdi
callq 0x1f7d0
movq -0x88(%rbp), %rdi
callq 0x20330
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x21b10
nopw %cs:(%rax,%rax)