LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByID_MinHopCount(int)
int findRowByID_MinHopCount(int id)
{
	int min_hop_count = 10000;
	int index = -1;
	for (int i = 0; i < table.size(); i++)
	{
		if (id == table[i].identifier)
		{
			if (table[i].hop_count < min_hop_count)
			{
				index = i;
				min_hop_count = table[i].hop_count;
			}
		}
	}
	return index;
}

// Assembly:
movq 0x74df(%rip), %rcx      # 0xa230
movq 0x74d0(%rip), %rdx      # 0xa228
subq %rdx, %rcx
sarq $0x6, %rcx
pushq $-0x1
popq %rax
movl $0x2710, %esi           # imm = 0x2710
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x2d8b
cmpl %edi, (%rdx)
jne 0x2d82
movl 0xc(%rdx), %r9d
cmpl %esi, %r9d
cmovll %r9d, %esi
cmovll %r8d, %eax
incq %r8
addq $0x40, %rdx
jmp 0x2d6a
retq
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> findAllRowsByType(string type)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (table[i].type == type)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movl %eax, 0xc(%rsp)
cltq
movq 0x7409(%rip), %rdx      # 0xa230
movq 0x73fa(%rip), %rcx      # 0xa228
subq %rcx, %rdx
sarq $0x6, %rdx
cmpq %rax, %rdx
jbe 0x2e65
shlq $0x6, %rax
leaq (%rcx,%rax), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x4261
testb %al, %al
je 0x2e5d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4938
movl 0xc(%rsp), %eax
incl %eax
jmp 0x2e1a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByFD(int)
vector<int> findAllRowsByFD(int fd)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq 0xc(%rsp), %r14
movl %eax, 0xc(%rsp)
movslq %eax, %rcx
movq 0x737e(%rip), %rsi      # 0xa230
movq 0x736f(%rip), %rdx      # 0xa228
subq %rdx, %rsi
sarq $0x6, %rsi
cmpq %rcx, %rsi
jbe 0x2ee2
shlq $0x6, %rcx
cmpl %ebp, 0x4(%rdx,%rcx)
jne 0x2ede
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4938
movl 0xc(%rsp), %eax
incl %eax
jmp 0x2ea4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: sendTableToAllRouters(int)
void sendTableToAllRouters(int ignore_fd = -1){
	auto index_vec = findAllRowsByType("ROUTER");

	for (int i=0; i<index_vec.size(); i++){

		if (table[index_vec[i]].fd == ignore_fd)
			continue;

		cout<<"Index is "<<index_vec[i]<<endl;

		string table_string = serialize (table);
		auto router = table[index_vec[i]];
		auto to_send = constructNewMessage(TABLE, port, router.identifier, (void*)table_string.c_str());
		send (router.fd, to_send.c_str(), to_send.size(), 0);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edi, %ebx
leaq 0x3184(%rip), %rsi      # 0x609f
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x48da
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2df9
leaq 0x38(%rsp), %rdi
callq 0x2100
xorl %r13d, %r13d
leaq 0x98(%rsp), %rbp
leaq 0x58(%rsp), %r14
leaq 0x18(%rsp), %r15
pushq $0x1
popq %r12
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x3035
movslq (%rax,%r13,4), %rax
movq 0x72aa(%rip), %rcx      # 0xa228
shlq $0x6, %rax
cmpl %ebx, 0x4(%rcx,%rax)
je 0x302d
movq 0x7035(%rip), %rdi      # 0x9fc8
leaq 0x310c(%rip), %rsi      # 0x60a6
callq 0x2240
movq (%rsp), %rcx
movl (%rcx,%r13,4), %esi
movq %rax, %rdi
callq 0x2390
movq %rax, %rdi
callq 0x2110
movq %rbp, %rdi
leaq 0x7267(%rip), %rsi      # 0xa228
callq 0x26b7
movq (%rsp), %rax
movslq (%rax,%r13,4), %rsi
shlq $0x6, %rsi
addq 0x724f(%rip), %rsi      # 0xa228
movq %r14, %rdi
callq 0x4956
movl 0x7259(%rip), %edx      # 0xa240
movl 0x58(%rsp), %ecx
movq 0x98(%rsp), %r8
movq %r15, %rdi
movl %r12d, %esi
callq 0x2880
movl 0x5c(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2120
movq %r15, %rdi
callq 0x2100
leaq 0x68(%rsp), %rdi
callq 0x2100
movq %rbp, %rdi
callq 0x2100
incq %r13
jmp 0x2f5a
movq %rsp, %rdi
callq 0x52a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
jmp 0x30a0
movq %rax, %rbx
jmp 0x30a0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2100
jmp 0x3075
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2100
jmp 0x3086
jmp 0x3095
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2100
jmp 0x3098
movq %rax, %rbx
movq %rsp, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CopyBrink(bbrink_t*)
bbrink_t *CopyBrink (bbrink_t *other)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);
	VectorCopy (other->direction, b->direction);
	VectorCopy (other->start, b->start);
	VectorCopy (other->stop, b->stop);
	b->numnodes = other->numnodes;
	b->nodes = new std::vector< bbrinknode_t >(*other->nodes);
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x4410
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
movups 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
pushq $0x18
popq %rdi
callq 0x42f0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0xf964
movq %r15, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x4300
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CreateBrink(double*, double*)
bbrink_t *CreateBrink (vec3_t start, vec3_t stop)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);

	VectorCopy (start, b->start);
	VectorCopy (stop, b->stop);
	VectorSubtract (stop, start, b->direction);

	b->numnodes = 1;
	b->nodes = new std::vector< bbrinknode_t >;
	bbrinknode_t newnode;
	newnode.isleaf = true;
	newnode.clipnode = NULL;
	b->nodes->push_back (newnode);
	
	// CreateBrink must be followed by BrinkSplitClipnode
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x60
popq %rdi
callq 0x4410
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x10(%r14), %xmm1
movsd %xmm1, 0x28(%rbx)
movupd (%r15), %xmm2
movupd %xmm2, (%rbx)
movupd (%r14), %xmm3
movupd %xmm3, 0x18(%rbx)
subpd %xmm2, %xmm3
movupd %xmm3, 0x30(%rbx)
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rbx)
movl $0x1, 0x48(%rbx)
pushq $0x18
popq %rdi
callq 0x42f0
andq $0x0, 0x10(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq %rax, 0x50(%rbx)
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
andq $0x0, 0x20(%rsi)
movq %rax, %rdi
callq 0xf9b8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: PrintBrink(bbrink_t const*)
void PrintBrink (const bbrink_t *b)
{
	Log ("direction %f %f %f start %f %f %f stop %f %f %f\n", b->direction[0], b->direction[1], b->direction[2], b->start[0], b->start[1], b->start[2], b->stop[0], b->stop[1], b->stop[2]);
	Log ("numnodes %d\n", b->numnodes);
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *n = &(*b->nodes)[i];
		if (n->isleaf)
		{
			Log ("leaf[%d] content %d\n", i, n->content);
		}
		else
		{
			Log ("node[%d]-[%d:%d] plane %f %f %f %f\n", i, n->children[0], n->children[1], n->plane->normal[0], n->plane->normal[1], n->plane->normal[2], n->plane->dist);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm0
movsd 0x38(%rdi), %xmm1
movsd 0x40(%rdi), %xmm2
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm4
movsd 0x10(%rdi), %xmm5
movsd 0x18(%rdi), %xmm6
movsd 0x20(%rdi), %xmm7
movsd 0x28(%rdi), %xmm8
movsd %xmm8, (%rsp)
leaq 0x1213e(%rip), %rdi     # 0x1e434
movb $0x8, %al
callq 0x8780
movl 0x48(%rbx), %esi
leaq 0x1215e(%rip), %rdi     # 0x1e465
xorl %eax, %eax
callq 0x8780
pushq $0x18
popq %r13
leaq 0x12159(%rip), %r14     # 0x1e472
leaq 0x12167(%rip), %r15     # 0x1e487
xorl %r12d, %r12d
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jge 0xc386
movq 0x50(%rbx), %rax
movq (%rax), %rax
cmpb $0x1, -0x18(%rax,%r13)
jne 0xc34e
movl (%rax,%r13), %edx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x8780
jmp 0xc37d
movl -0x8(%rax,%r13), %edx
movl -0x4(%rax,%r13), %ecx
movq -0x10(%rax,%r13), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x30(%rax), %xmm3
movq %r15, %rdi
movl %r12d, %esi
movb $0x4, %al
callq 0x8780
incq %r12
addq $0x28, %r13
jmp 0xc323
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BrinkSplitClipnode(bbrink_t*, plane_t const*, int, bclipnode_s*, bclipnode_s*, bclipnode_s*)
void BrinkSplitClipnode (bbrink_t *b, const dplane_t *plane, int planenum, bclipnode_t *prev, bclipnode_t *n0, bclipnode_t *n1)
{
	int found;
	int numfound = 0;
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *node = &(*b->nodes)[i];
		if (node->isleaf && node->clipnode == prev)
		{
			found = i;
			numfound++;
		}
	}
	if (numfound == 0)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: couldn't find clipnode");
		hlassume (false, assume_first);
	}
	if (numfound > 1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: found more than one clipnode");
		hlassume (false, assume_first);
	}
	if (n0 == n1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: n0 == n1");
		hlassume (false, assume_first);
	}
	b->nodes->resize (b->numnodes + 2);
	bbrinknode_t *node = &(*b->nodes)[found];
	bbrinknode_t *front = &(*b->nodes)[b->numnodes];
	bbrinknode_t *back = &(*b->nodes)[b->numnodes + 1];
	
	node->clipnode = NULL;
	node->isleaf = false;
	node->plane = plane;
	node->planenum = planenum;
	node->children[0] = b->numnodes;
	node->children[1] = b->numnodes + 1;
	
	front->isleaf = true;
	front->content = n0->content;
	front->clipnode = n0;

	back->isleaf = true;
	back->content = n1->content;
	back->clipnode = n1;

	b->numnodes += 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movl 0x48(%rdi), %eax
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
pushq $0x20
popq %rdi
xorl %esi, %esi
cmpq %rdx, %rax
je 0xc3ec
movq 0x50(%r14), %r8
movq (%r8), %r8
cmpq %rcx, (%r8,%rdi)
sete %r9b
andb -0x20(%r8,%rdi), %r9b
movzbl %r9b, %r8d
addl %r8d, %esi
testb %r8b, %r8b
cmovnel %edx, %r13d
incq %rdx
addq $0x28, %rdi
jmp 0xc3bc
testl %esi, %esi
je 0xc3fe
cmpl $0x1, %esi
je 0xc415
leaq 0x120ea(%rip), %rdi     # 0x1e4e6
jmp 0xc405
leaq 0x120a6(%rip), %rdi     # 0x1e4ab
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
cmpq %rbx, %r15
jne 0xc431
leaq 0x12106(%rip), %rdi     # 0x1e527
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq 0x50(%r14), %rdi
movslq 0x48(%r14), %rsi
addq $0x2, %rsi
callq 0xf9e6
movq 0x50(%r14), %rax
movslq %r13d, %rcx
movq (%rax), %rax
imulq $0x28, %rcx, %rcx
movslq 0x48(%r14), %rdx
andq $0x0, 0x20(%rax,%rcx)
imulq $0x28, %rdx, %rdx
movb $0x0, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
movl %ebp, 0x4(%rax,%rcx)
movl 0x48(%r14), %esi
movl %esi, 0x10(%rax,%rcx)
incl %esi
movl %esi, 0x14(%rax,%rcx)
movb $0x1, %cl
movb %cl, (%rax,%rdx)
movl 0x20(%r15), %esi
movl %esi, 0x18(%rax,%rdx)
movq %r15, 0x20(%rax,%rdx)
movb %cl, 0x28(%rax,%rdx)
movl 0x20(%rbx), %ecx
movl %ecx, 0x40(%rax,%rdx)
movq %rbx, 0x48(%rax,%rdx)
addl $0x2, 0x48(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BrinkReplaceClipnode(bbrink_t*, bclipnode_s*, bclipnode_s*)
void BrinkReplaceClipnode (bbrink_t *b, bclipnode_t *prev, bclipnode_t *n)
{
	int found;
	int numfound = 0;
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *node = &(*b->nodes)[i];
		if (node->isleaf && node->clipnode == prev)
		{
			found = i;
			numfound++;
		}
	}
	if (numfound == 0)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: couldn't find clipnode");
		hlassume (false, assume_first);
	}
	if (numfound > 1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: found more than one clipnode");
		hlassume (false, assume_first);
	}
	bbrinknode_t *node = &(*b->nodes)[found];
	node->clipnode = n;
	node->content = n->content;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x48(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
pushq $0x20
popq %rdi
xorl %edx, %edx
cmpq %rcx, %rax
je 0xc4f7
movq 0x50(%r14), %r8
movq (%r8), %r8
cmpq %rsi, (%r8,%rdi)
sete %r9b
andb -0x20(%r8,%rdi), %r9b
movzbl %r9b, %r8d
addl %r8d, %edx
testb %r8b, %r8b
cmovnel %ecx, %ebp
incq %rcx
addq $0x28, %rdi
jmp 0xc4c8
testl %edx, %edx
je 0xc509
cmpl $0x1, %edx
je 0xc520
leaq 0x11fdf(%rip), %rdi     # 0x1e4e6
jmp 0xc510
leaq 0x11f9b(%rip), %rdi     # 0x1e4ab
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq 0x50(%r14), %rax
movslq %ebp, %rcx
movq (%rax), %rax
imulq $0x28, %rcx, %rcx
movq %rbx, 0x20(%rax,%rcx)
movl 0x20(%rbx), %edx
movl %edx, 0x18(%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreepoint(int&, bool)
btreepoint_t *AllocTreepoint (int &numobjects, bool infinite)
{
	numobjects++;
	btreepoint_t *tp = (btreepoint_t *)malloc (sizeof (btreepoint_t));
	hlassume (tp != NULL, assume_NoMemory);
	tp->edges = new btreeedge_l ();
	tp->infinite = infinite;
	return tp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
incl (%rdi)
pushq $0x40
popq %rdi
callq 0x4410
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
pushq $0x18
popq %rdi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x20(%r14)
movb %bl, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeedge(int&, bool)
btreeedge_t *AllocTreeedge (int &numobjects, bool infinite)
{
	numobjects++;
	btreeedge_t *te = (btreeedge_t *)malloc (sizeof (btreeedge_t));
	hlassume (te != NULL, assume_NoMemory);
	te->points[0].p = NULL;
	te->points[0].side = false;
	te->points[1].p = NULL;
	te->points[1].side = true;
	te->faces = new btreeface_l ();
	te->infinite = infinite;
	// should be followed by SetEdgePoints
	return te;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
incl (%rdi)
pushq $0x48
popq %rdi
callq 0x4410
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
andq $0x0, (%r14)
movb $0x0, 0x8(%r14)
andq $0x0, 0x10(%r14)
movb $0x1, 0x18(%r14)
pushq $0x18
popq %rdi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x28(%r14)
movb %bl, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachPointToEdge(btreeedge_s*, btreepoint_s*, bool)
void AttachPointToEdge (btreeedge_t *te, btreepoint_t *tp, bool side)
{
	if (te->points[side].p)
	{
		PrintOnce ("AttachPointToEdge: internal error: point occupied.");
		hlassume (false, assume_first);
	}
	if (te->infinite && !tp->infinite)
	{
		PrintOnce ("AttachPointToEdge: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	te->points[side].p = tp;

	btreeedge_r er;
	er.e = te;
	er.side = side;
	tp->edges->push_back (er);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
shll $0x4, %r15d
cmpq $0x0, (%rdi,%r15)
je 0xc61f
leaq 0x11f45(%rip), %rdi     # 0x1e554
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
addq %r14, %r15
cmpb $0x1, 0x20(%r14)
jne 0xc646
cmpb $0x0, 0x18(%rbx)
jne 0xc646
leaq 0x11f51(%rip), %rdi     # 0x1e587
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq %rbx, (%r15)
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movb %bpl, 0x8(%rsi)
movq 0x20(%rbx), %rdi
callq 0xfa1e
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeface(int&, bool)
btreeface_t *AllocTreeface (int &numobjects, bool infinite)
{
	numobjects++;
	btreeface_t *tf = (btreeface_t *)malloc (sizeof (btreeface_t));
	hlassume (tf != NULL, assume_NoMemory);
	tf->edges = new btreeedge_l ();
	tf->leafs[0].l = NULL;
	tf->leafs[0].side = false;
	tf->leafs[1].l = NULL;
	tf->leafs[1].side = true;
	tf->infinite = infinite;
	return tf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
incl (%rdi)
pushq $0x48
popq %rdi
callq 0x4410
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
pushq $0x18
popq %rdi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
andq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
movb %bl, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachEdgeToFace(btreeface_s*, btreeedge_s*, int)
void AttachEdgeToFace (btreeface_t *tf, btreeedge_t *te, int side)
{
	if (tf->infinite && !te->infinite)
	{
		PrintOnce ("AttachEdgeToFace: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	btreeedge_r er;
	er.e = te;
	er.side = side;
	tf->edges->push_back (er);

	btreeface_r fr;
	fr.f = tf;
	fr.side = side;
	te->faces->push_back (fr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xc720
cmpb $0x0, 0x20(%rbx)
jne 0xc720
leaq 0x11ecb(%rip), %rdi     # 0x1e5db
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
testl %ebp, %ebp
setne 0x8(%rsi)
movq (%r14), %rdi
callq 0xfa1e
testl %ebp, %ebp
movq %rsp, %rsi
movq %r14, (%rsi)
setne 0x8(%rsi)
movq 0x28(%rbx), %rdi
callq 0xfa2a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachFaceToLeaf(btreeleaf_s*, btreeface_s*, int)
void AttachFaceToLeaf (btreeleaf_t *tl, btreeface_t *tf, int side)
{
	if (tl->infinite && !tf->infinite)
	{
		PrintOnce ("AttachFaceToLeaf: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	btreeface_r fr;
	fr.f = tf;
	fr.side = side;
	tl->faces->push_back (fr);

	if (tf->leafs[side].l)
	{
		PrintOnce ("AttachFaceToLeaf: internal error: leaf occupied.");
		hlassume (false, assume_first);
	}
	tf->leafs[side].l = tl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0xc788
cmpb $0x0, 0x8(%r14)
jne 0xc788
leaq 0x11eb6(%rip), %rdi     # 0x1e62e
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq %rsp, %rsi
movq %r14, (%rsi)
testl %ebp, %ebp
setne 0x8(%rsi)
movq (%rbx), %rdi
callq 0xfa2a
movslq %ebp, %rax
shlq $0x4, %rax
addq %rax, %r14
addq $0x10, %r14
cmpq $0x0, (%r14)
je 0xc7c7
leaq 0x11eca(%rip), %rdi     # 0x1e681
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeleaf(int&, bool)
btreeleaf_t *AllocTreeleaf (int &numobjects, bool infinite)
{
	numobjects++;
	btreeleaf_t *tl = (btreeleaf_t *)malloc (sizeof (btreeleaf_t));
	hlassume (tl != NULL, assume_NoMemory);
	tl->faces = new btreeface_l ();
	tl->infinite = infinite;
	return tl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
incl (%rdi)
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x4410
movq %rax, %r15
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
movq %r14, %rdi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%r15)
movb %bl, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: GetPointFromEdge(btreeedge_s*, bool)
btreepoint_t *GetPointFromEdge (btreeedge_t *te, bool side)
{
	if (!te->points[side].p)
	{
		PrintOnce ("GetPointFromEdge: internal error: point not set.");
		hlassume (false, assume_first);
	}
	return te->points[side].p;
}

// Assembly:
shll $0x4, %esi
movq (%rdi,%rsi), %rax
testq %rax, %rax
je 0xcd20
retq
pushq %rbx
movq %rdi, %rbx
addq %rsi, %rbx
leaq 0x11984(%rip), %rdi     # 0x1e6b2
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: RemoveEdgeFromList(std::__cxx11::list<btreeedge_r, std::allocator<btreeedge_r>>*, btreeedge_s*, bool)
void RemoveEdgeFromList (btreeedge_l *el, btreeedge_t *te, bool side)
{
	btreeedge_l::iterator ei;
	for (ei = el->begin (); ei != el->end (); ei++)
	{
		if (ei->e == te && ei->side == side)
		{
			el->erase (ei);
			return; // only remove one copy if there are many (in order to preserve topological correctness)
		}
	}
	PrintOnce ("RemoveEdgeFromList: internal error: edge not found.");
	hlassume (false, assume_first);
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq (%rax), %rax
cmpq %rdi, %rax
je 0xcd63
cmpq %rsi, 0x10(%rax)
jne 0xcd47
cmpb %dl, 0x18(%rax)
jne 0xcd47
movq %rax, %rsi
popq %rax
jmp 0xfa36
leaq 0x11979(%rip), %rdi     # 0x1e6e3
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
popq %rax
jmp 0x92bb
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: RemovePointFromEdge(btreeedge_s*, btreepoint_s*, bool)
void RemovePointFromEdge (btreeedge_t *te, btreepoint_t *tp, bool side) // warning: the point will not be freed
{
	if (te->points[side].p != tp)
	{
		PrintOnce ("RemovePointFromEdge: internal error: point not found.");
		hlassume (false, assume_first);
	}
	te->points[side].p = NULL;

	RemoveEdgeFromList (tp->edges, te, side);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %eax
shll $0x4, %eax
leaq (%rdi,%rax), %r15
cmpq %rsi, (%rdi,%rax)
je 0xcdb0
leaq 0x11977(%rip), %rdi     # 0x1e717
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
andq $0x0, (%r15)
movq 0x20(%r14), %rdi
movzbl %bpl, %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcd43
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeletePoint(int&, btreepoint_s*)
void DeletePoint (int &numobjects, btreepoint_t *tp)
{
	if (!tp->edges->empty ())
	{
		PrintOnce ("DeletePoint: internal error: point used by edge.");
		hlassume (false, assume_first);
	}
	delete tp->edges;
	free (tp);
	numobjects--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r15
cmpq %r15, (%r15)
je 0xce02
leaq 0x11964(%rip), %rdi     # 0x1e74d
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq 0x20(%r14), %r15
testq %r15, %r15
je 0xce0c
movq %r15, %rdi
callq 0xfb62
jmp 0xce0f
xorl %r15d, %r15d
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4390
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: RemoveFaceFromList(std::__cxx11::list<btreeface_r, std::allocator<btreeface_r>>*, btreeface_s*, bool)
void RemoveFaceFromList (btreeface_l *fl, btreeface_t *tf, bool side)
{
	btreeface_l::iterator fi;
	for (fi = fl->begin (); fi != fl->end (); fi++)
	{
		if (fi->f == tf && fi->side == side)
		{
			fl->erase (fi);
			return;
		}
	}
	PrintOnce ("RemoveFaceFromList: internal error: face not found.");
	hlassume (false, assume_first);
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq (%rax), %rax
cmpq %rdi, %rax
je 0xce4a
cmpq %rsi, 0x10(%rax)
jne 0xce2e
cmpb %dl, 0x18(%rax)
jne 0xce2e
movq %rax, %rsi
popq %rax
jmp 0xfa44
leaq 0x1192d(%rip), %rdi     # 0x1e77e
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
popq %rax
jmp 0x92bb
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteEdge(int&, btreeedge_s*)
void DeleteEdge (int &numobjects, btreeedge_t *te) // warning: points in this edge could be freed if not reference by any other edges
{
	if (!te->faces->empty ())
	{
		PrintOnce ("DeleteEdge: internal error: edge used by face.");
		hlassume (false, assume_first);
	}
	if (!te->infinite)
	{
		DeleteBrink (te->brink);
	}
	for (int side = 0; side < 2; side++)
	{
		btreepoint_t *tp;
		tp = GetPointFromEdge (te, side);
		RemovePointFromEdge (te, tp, side);
		if (tp->edges->empty ())
		{
			DeletePoint (numobjects, tp);
		}
	}
	delete te->faces;
	free (te);
	numobjects--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
cmpq %rax, (%rax)
je 0xceb8
leaq 0x1190a(%rip), %rdi     # 0x1e7b2
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
cmpb $0x0, 0x20(%r14)
jne 0xcec8
movq 0x30(%r14), %rdi
callq 0xc1d2
pushq $0x2
popq %rax
movl %eax, %r12d
subl $0x1, %r12d
jb 0xcf13
xorl %ebp, %ebp
cmpl $0x2, %eax
setne %bpl
movq %r14, %rdi
movl %ebp, %esi
callq 0xcd13
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0xcd7b
movq 0x20(%r15), %rcx
movl %r12d, %eax
cmpq %rcx, (%rcx)
jne 0xcecb
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcdce
movl %r12d, %eax
jmp 0xcecb
movq 0x28(%r14), %r15
testq %r15, %r15
je 0xcf24
movq %r15, %rdi
callq 0xfb8c
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4390
decl (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: GetLeafFromFace(btreeface_s*, bool)
btreeleaf_t *GetLeafFromFace (btreeface_t *tf, bool side)
{
	if (!tf->leafs[side].l)
	{
		PrintOnce ("GetLeafFromFace: internal error: Leaf not set.");
		hlassume (false, assume_first);
	}
	return tf->leafs[side].l;
}

// Assembly:
shll $0x4, %esi
movq 0x10(%rdi,%rsi), %rax
testq %rax, %rax
je 0xcf50
retq
pushq %rbx
leaq (%rdi,%rsi), %rbx
addq $0x10, %rbx
leaq 0x11881(%rip), %rdi     # 0x1e7e1
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: RemoveFaceFromLeaf(btreeleaf_s*, btreeface_s*, bool)
void RemoveFaceFromLeaf (btreeleaf_t *tl, btreeface_t *tf, bool side)
{
	if (tf->leafs[side].l != tl)
	{
		PrintOnce ("RemoveFaceFromLeaf: internal error: leaf not found.");
		hlassume (false, assume_first);
	}
	tf->leafs[side].l = NULL;

	RemoveFaceFromList (tl->faces, tf, side);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
shll $0x4, %eax
leaq (%rsi,%rax), %r15
addq $0x10, %r15
cmpq %rdi, (%r15)
je 0xcfad
leaq 0x11873(%rip), %rdi     # 0x1e810
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
andq $0x0, (%r15)
movq (%r14), %rdi
movzbl %bpl, %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xce2a
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteFace(int&, btreeface_s*)
void DeleteFace (int &numobjects, btreeface_t *tf) // warning: edges in this face could be freed if not reference by any other faces
{
	btreeedge_l::iterator ei;
	while ((ei = tf->edges->begin ()) != tf->edges->end ())
	{
		btreeedge_t *te = ei->e;
		RemoveFaceFromList (te->faces, tf, ei->side);
		tf->edges->erase (ei);
		if (te->faces->empty ())
		{
			DeleteEdge (numobjects, te);
		}
	}
	for (int side = 0; side < 2; side++)
	{
		if (tf->leafs[side].l)
		{
			PrintOnce ("DeleteFace: internal error: face used by leaf.");
			hlassume (false, assume_first);
		}
	}
	delete tf->edges;
	free (tf);
	numobjects--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%r14), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0xd01b
movq 0x10(%r12), %r15
movq 0x28(%r15), %rdi
movzbl 0x18(%r12), %edx
movq %r14, %rsi
callq 0xce2a
movq (%r14), %rdi
movq %r12, %rsi
callq 0xfa36
movq 0x28(%r15), %rax
cmpq %rax, (%rax)
jne 0xcfd8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xce8a
jmp 0xcfd8
pushq $0x10
popq %r12
leaq 0x1181e(%rip), %r15     # 0x1e844
cmpq $0x30, %r12
je 0xd04c
cmpq $0x0, (%r14,%r12)
je 0xd046
movq %r15, %rdi
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
addq $0x10, %r12
jmp 0xd026
movq (%r14), %r15
testq %r15, %r15
je 0xd05c
movq %r15, %rdi
callq 0xfb62
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4390
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteLeaf(int&, btreeleaf_s*)
void DeleteLeaf (int &numobjects, btreeleaf_t *tl)
{
	btreeface_l::iterator fi;
	while ((fi = tl->faces->begin ()) != tl->faces->end ())
	{
		btreeface_t *tf = fi->f;
		RemoveFaceFromLeaf (tl, tf, fi->side);
		if (!tf->leafs[false].l && !tf->leafs[true].l)
		{
			DeleteFace (numobjects, tf);
		}
	}
	delete tl->faces;
	free (tl);
	numobjects--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%r14), %r15
movq (%r15), %rax
cmpq %r15, %rax
je 0xd0c1
movq 0x10(%rax), %r15
movzbl 0x18(%rax), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xcf75
cmpq $0x0, 0x10(%r15)
jne 0xd088
cmpq $0x0, 0x20(%r15)
jne 0xd088
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcfca
jmp 0xd088
movq %r15, %rdi
callq 0xfb8c
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4390
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BuildTreeCells_r(int&, bclipnode_s*)
void BuildTreeCells_r (int &numobjects, bclipnode_t *c)
{
	if (c->isleaf)
	{
		return;
	}
	btreeleaf_t *tl, *front, *back;
	tl = c->treeleaf;
	SplitTreeLeaf (numobjects, tl, c->plane, c->planenum, ON_EPSILON, front, back, c->children[0], c->children[1]);
	c->treeleaf = NULL;
	c->children[0]->treeleaf = front;
	c->children[1]->treeleaf = back;
	BuildTreeCells_r (numobjects, c->children[0]);
	BuildTreeCells_r (numobjects, c->children[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %r12
cmpb $0x0, (%rbx)
jne 0xdf2e
movq 0x30(%rbx), %rsi
movq 0x8(%rbx), %rdx
movl 0x4(%rbx), %ecx
movups 0x10(%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movsd 0x104ee(%rip), %xmm0    # 0x1e3e0
movq %r15, %r8
movq %r12, %r9
callq 0xd0e4
andq $0x0, 0x30(%rbx)
movq 0x20(%rsp), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x30(%rcx)
movq 0x18(%rsp), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x30(%rcx)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xdeb4
movq 0x18(%rbx), %rbx
jmp 0xdecf
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: ExpandClipnodes_r(bclipnode_s*, int&, dclipnode_t const*, int)
bclipnode_t *ExpandClipnodes_r (bclipnode_t *bclipnodes, int &numbclipnodes, const dclipnode_t *clipnodes, int headnode)
{
	if (numbclipnodes >= MAXCLIPNODES)
	{
		Error ("ExpandClipnodes_r: exceeded MAXCLIPNODES");
	}
	bclipnode_t *c = &bclipnodes[numbclipnodes];
	numbclipnodes++;
	if (headnode < 0)
	{
		c->isleaf = true;
		c->content = headnode;
		c->partitions = NULL;
	}
	else
	{
		c->isleaf = false;
		c->planenum = clipnodes[headnode].planenum;
		c->plane = &g_dplanes[c->planenum];
		for (int k = 0; k < 2; k++)
		{
			c->children[k] = ExpandClipnodes_r (bclipnodes, numbclipnodes, clipnodes, clipnodes[headnode].children[k]);
		}
	}
	return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0x3fff8, %eax          # imm = 0x3FFF8
jl 0xdf6a
leaq 0x10a76(%rip), %rdi     # 0x1e9d6
xorl %eax, %eax
callq 0x8b1f
movl (%r14), %eax
cltq
imulq $0x38, %rax, %r12
addq %r15, %r12
incl %eax
movl %eax, (%r14)
testl %ebp, %ebp
js 0xdfc6
movb $0x0, (%r12)
movl %ebp, %eax
leaq (%rbx,%rax,8), %r13
movslq (%r13), %rax
movl %eax, 0x4(%r12)
shlq $0x6, %rax
addq 0x1b00d(%rip), %rax     # 0x28fa8
movq %rax, 0x8(%r12)
xorl %ebp, %ebp
cmpq $0x2, %rbp
je 0xdfd6
movswl 0x4(%r13,%rbp,2), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdf3a
movq %rax, 0x10(%r12,%rbp,8)
incq %rbp
jmp 0xdfa2
movb $0x1, (%r12)
movl %ebp, 0x20(%r12)
andq $0x0, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: ExpandClipnodes(bbrinkinfo_s*, dclipnode_t const*, int)
void ExpandClipnodes (bbrinkinfo_t *info, const dclipnode_t *clipnodes, int headnode)
{
	bclipnode_t *bclipnodes = (bclipnode_t *)malloc (MAXCLIPNODES * sizeof (bclipnode_t)); // 262144 * 30byte = 7.5MB
	hlassume (bclipnodes != NULL, assume_NoMemory);
	info->numclipnodes = 0;
	ExpandClipnodes_r (bclipnodes, info->numclipnodes, clipnodes, headnode);
	info->clipnodes = (bclipnode_t *)malloc (info->numclipnodes * sizeof (bclipnode_t));
	hlassume (info->clipnodes != NULL, assume_NoMemory);
	memcpy (info->clipnodes, bclipnodes, info->numclipnodes * sizeof (bclipnode_t));
	for (int i = 0; i < info->numclipnodes; i++)
	{
		for (int k = 0; k < 2; k++)
		{
			info->clipnodes[i].children[k] = info->clipnodes + (bclipnodes[i].children[k] - bclipnodes);
		}
	}
	free (bclipnodes);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0xdffe40, %edi         # imm = 0xDFFE40
callq 0x4410
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %r12
movl %r12d, %esi
callq 0x92bb
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xdf3a
movslq (%rbx), %rax
imulq $0x38, %rax, %rdi
callq 0x4410
movq %rax, 0x8(%rbx)
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl %r12d, %esi
callq 0x92bb
movq 0x8(%rbx), %rdi
movslq (%rbx), %rax
imulq $0x38, %rax, %rdx
movq %r14, %rsi
callq 0x4260
leaq 0x10(%r14), %rax
pushq $0x10
popq %rcx
xorl %edx, %edx
movslq (%rbx), %rsi
cmpq %rsi, %rdx
jge 0xe0a1
xorl %esi, %esi
cmpq $0x2, %rsi
je 0xe094
movq 0x8(%rbx), %rdi
movq (%rax,%rsi,8), %r8
subq %r14, %r8
addq %rdi, %r8
addq %rcx, %rdi
movq %r8, (%rdi,%rsi,8)
incq %rsi
jmp 0xe074
incq %rdx
addq $0x38, %rax
addq $0x38, %rcx
jmp 0xe06a
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4390
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BuildTreeCells(bbrinkinfo_s*)
void BuildTreeCells (bbrinkinfo_t *info)
{
	info->numobjects = 0;
	info->leaf_outside = BuildOutside (info->numobjects);
	info->clipnodes[0].treeleaf = BuildBaseCell (info->numobjects, &info->clipnodes[0], BOGUS_RANGE, info->leaf_outside);
	BuildTreeCells_r (info->numobjects, &info->clipnodes[0]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
andl $0x0, 0x10(%rdi)
movq %r14, %rdi
callq 0xc84c
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rsi
movsd 0x10310(%rip), %xmm0    # 0x1e3e8
movq %r14, %rdi
movq %rax, %rdx
callq 0xc85c
movq 0x8(%rbx), %rcx
movq %rax, 0x30(%rcx)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdeb4
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteTreeCells_r(int&, bclipnode_s*)
void DeleteTreeCells_r (int &numobjects, bclipnode_t *node)
{
	if (node->treeleaf)
	{
		DeleteLeaf (numobjects, node->treeleaf);
		node->treeleaf = NULL;
	}
	if (!node->isleaf)
	{
		DeleteTreeCells_r (numobjects, node->children[0]);
		DeleteTreeCells_r (numobjects, node->children[1]);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0xe11e
movq %r14, %rdi
callq 0xd07d
andq $0x0, 0x30(%rbx)
cmpb $0x0, (%rbx)
jne 0xe135
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xe0fe
movq 0x18(%rbx), %rbx
jmp 0xe108
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteTreeCells(bbrinkinfo_s*)
void DeleteTreeCells (bbrinkinfo_t *info)
{
	DeleteLeaf (info->numobjects, info->leaf_outside);
	info->leaf_outside = NULL;
	DeleteTreeCells_r (info->numobjects, &info->clipnodes[0]);
	if (info->numobjects != 0)
	{
		PrintOnce ("DeleteTreeCells: internal error: numobjects != 0");
		hlassume (false, assume_first);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x18(%rdi), %rsi
movq %r14, %rdi
callq 0xd07d
andq $0x0, 0x18(%rbx)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xe0fe
cmpl $0x0, 0x10(%rbx)
je 0xe189
leaq 0x1088d(%rip), %rdi     # 0x1e9ff
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92bb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: ClearMarks_r(bclipnode_s*)
void ClearMarks_r (bclipnode_t *node)
{
	if (node->isleaf)
	{
		btreeface_l::iterator fi;
		btreeedge_l::iterator ei;
		for (fi = node->treeleaf->faces->begin (); fi != node->treeleaf->faces->end (); fi++)
		{
			for (ei = fi->f->edges->begin (); ei != fi->f->edges->end (); ei++)
			{
				ei->e->tmp_tested = false;
			}
		}
	}
	else
	{
		ClearMarks_r (node->children[0]);
		ClearMarks_r (node->children[1]);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, (%rbx)
je 0xe1a9
movq 0x10(%rbx), %rdi
callq 0xe191
movq 0x18(%rbx), %rbx
jmp 0xe195
movq 0x30(%rbx), %rax
movq (%rax), %rcx
movq %rcx, %rax
movq (%rax), %rax
cmpq %rcx, %rax
je 0xe1e7
movq 0x10(%rax), %rcx
movq (%rcx), %rdx
movq %rdx, %rcx
movq (%rcx), %rcx
cmpq %rdx, %rcx
je 0xe1de
movq 0x10(%rcx), %rdx
movb $0x0, 0x38(%rdx)
movq 0x10(%rax), %rdx
movq (%rdx), %rdx
jmp 0xe1c5
movq 0x30(%rbx), %rcx
movq (%rcx), %rcx
jmp 0xe1b3
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CollectBrinks_r(bclipnode_s*, int&, bbrink_t**)
void CollectBrinks_r (bclipnode_t *node, int &numbrinks, bbrink_t **brinks)
{
	if (node->isleaf)
	{
		btreeface_l::iterator fi;
		btreeedge_l::iterator ei;
		for (fi = node->treeleaf->faces->begin (); fi != node->treeleaf->faces->end (); fi++)
		{
			for (ei = fi->f->edges->begin (); ei != fi->f->edges->end (); ei++)
			{
				if (ei->e->tmp_tested)
				{
					continue;
				}
				ei->e->tmp_tested = true;
				if (!ei->e->infinite)
				{
					if (brinks != NULL)
					{
						brinks[numbrinks] = ei->e->brink;
						brinks[numbrinks]->edge = ei->e;
						for (int i = 0; i < brinks[numbrinks]->numnodes; i++)
						{
							bbrinknode_t *node = &(*brinks[numbrinks]->nodes)[i];
							if (node->isleaf && !node->clipnode->isleaf)
							{
								PrintOnce ("CollectBrinks_r: internal error: not leaf");
								hlassume (false, assume_first);
							}
						}
					}
					numbrinks++;
				}
			}
		}
	}
	else
	{
		CollectBrinks_r (node->children[0], numbrinks, brinks);
		CollectBrinks_r (node->children[1], numbrinks, brinks);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, (%r15)
je 0xe218
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1e9
movq 0x18(%r15), %r15
jmp 0xe1fd
movq 0x30(%r15), %rax
movq (%rax), %rax
movq %rax, %rbp
movq %r15, (%rsp)
movq (%rbp), %rbp
cmpq %rax, %rbp
je 0xe2f7
movq 0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, %r13
movq (%r13), %r13
cmpq %rax, %r13
je 0xe2e7
movq 0x10(%r13), %rax
cmpb $0x0, 0x38(%rax)
jne 0xe2db
movb $0x1, 0x38(%rax)
movq 0x10(%r13), %rcx
cmpb $0x0, 0x20(%rcx)
jne 0xe2db
movl (%r14), %eax
testq %rbx, %rbx
je 0xe2d6
cltq
movq 0x30(%rcx), %rcx
movq %rcx, (%rbx,%rax,8)
movq 0x10(%r13), %rax
movslq (%r14), %rcx
movq (%rbx,%rcx,8), %rcx
movq %rax, 0x58(%rcx)
pushq $0x20
popq %r15
xorl %r12d, %r12d
movslq (%r14), %rax
movq (%rbx,%rax,8), %rcx
movslq 0x48(%rcx), %rdx
cmpq %rdx, %r12
jge 0xe2d6
movq 0x50(%rcx), %rax
movq (%rax), %rax
cmpb $0x1, -0x20(%rax,%r15)
jne 0xe2cd
movq (%rax,%r15), %rax
cmpb $0x0, (%rax)
jne 0xe2cd
leaq 0x10773(%rip), %rdi     # 0x1ea30
xorl %eax, %eax
callq 0x8d93
xorl %edi, %edi
xorl %esi, %esi
callq 0x92bb
incq %r12
addq $0x28, %r15
jmp 0xe28e
incl %eax
movl %eax, (%r14)
movq 0x10(%rbp), %rax
movq (%rax), %rax
jmp 0xe23d
movq (%rsp), %r15
movq 0x30(%r15), %rax
movq (%rax), %rax
jmp 0xe226
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CollectBrinks(bbrinkinfo_s*)
void CollectBrinks (bbrinkinfo_t *info)
{
	info->numbrinks = 0;
	ClearMarks_r (&info->clipnodes[0]);
	CollectBrinks_r (&info->clipnodes[0], info->numbrinks, NULL);
	hlassume (info->brinks = (bbrink_t **)malloc (info->numbrinks * sizeof (bbrink_t *)), assume_NoMemory);
	info->numbrinks = 0;
	ClearMarks_r (&info->clipnodes[0]);
	CollectBrinks_r (&info->clipnodes[0], info->numbrinks, info->brinks);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
andl $0x0, 0x20(%rdi)
movq 0x8(%rdi), %rdi
callq 0xe191
movq 0x8(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe1e9
movslq 0x20(%r14), %rdi
shlq $0x3, %rdi
callq 0x4410
movq %rax, 0x28(%r14)
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
andl $0x0, 0x20(%r14)
movq 0x8(%r14), %rdi
callq 0xe191
movq 0x8(%r14), %rdi
movq 0x28(%r14), %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe1e9
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: PrintCircle(bcircle_t const*)
void PrintCircle (const bcircle_t *c)
{
	Log ("axis %f %f %f\n", c->axis[0], c->axis[1], c->axis[2]);
	Log ("basenormal %f %f %f\n", c->basenormal[0], c->basenormal[1], c->basenormal[2]);
	Log ("numwedges %d %d\n", c->numwedges[0], c->numwedges[1]);
	for (int side = 0; side < 2; side++)
	{
		for (int i = 0; i < c->numwedges[side]; i++)
		{
			const bwedge_t *w = &c->wedges[side][i];
			const bsurface_t *s = &c->surfaces[side][i];
			Log ("surface[%d][%d] nodenum %d nodeside %d normal %f %f %f\n", side, i, s->nodenum, s->nodeside, s->normal[0], s->normal[1], s->normal[2]);
			Log ("wedge[%d][%d] nodenum %d content %d\n", side, i, w->nodenum, w->content);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
leaq 0x10148(%rip), %rdi     # 0x1eaa6
movb $0x3, %al
callq 0x8780
movsd 0x18(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
movsd 0x28(%rbx), %xmm2
leaq 0x1013a(%rip), %rdi     # 0x1eab5
movb $0x3, %al
callq 0x8780
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
leaq 0x1013b(%rip), %rdi     # 0x1eaca
xorl %eax, %eax
callq 0x8780
movl $0x62a, %ebp            # imm = 0x62A
leaq 0x10139(%rip), %r14     # 0x1eadb
leaq 0x1016a(%rip), %r15     # 0x1eb13
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0xea26
movq %rbp, (%rsp)
xorl %r13d, %r13d
movslq 0x30(%rbx,%r12,4), %rax
cmpq %rax, %r13
jge 0xea16
movl -0x4(%rbx,%rbp,2), %ecx
movzbl (%rbx,%rbp,2), %r8d
movsd -0x1c(%rbx,%rbp,2), %xmm0
movsd -0x14(%rbx,%rbp,2), %xmm1
movsd -0xc(%rbx,%rbp,2), %xmm2
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
movb $0x3, %al
callq 0x8780
movl -0x5f2(%rbx,%rbp), %r8d
movl -0x5ee(%rbx,%rbp), %ecx
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
xorl %eax, %eax
callq 0x8780
incq %r13
addq $0x18, %rbp
jmp 0xe9b9
incq %r12
movq (%rsp), %rbp
addq $0x600, %rbp            # imm = 0x600
jmp 0xe9ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: DeleteClipnodes(bbrinkinfo_s*)
void DeleteClipnodes (bbrinkinfo_t *info)
{
	for (int i = 0; i < info->numclipnodes; i++)
	{
#ifdef HLBSP_BRINKHACK_BUGFIX
		if (!info->clipnodes[i].isleaf)
		{
			continue;
		}
#endif
		bpartition_t *p;
		while ((p = info->clipnodes[i].partitions) != NULL)
		{
			info->clipnodes[i].partitions = p->next;
			free (p);
		}
	}
	free (info->clipnodes);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0xf331
imulq $0x38, %r14, %r15
cmpb $0x1, (%rdi,%r15)
jne 0xf32c
movq 0x28(%rdi,%r15), %rax
testq %rax, %rax
je 0xf32c
leaq (%rdi,%r15), %rcx
addq $0x28, %rcx
movq 0x10(%rax), %rdx
movq %rdx, (%rcx)
movq %rax, %rdi
callq 0x4390
movq 0x8(%rbx), %rdi
jmp 0xf305
incq %r14
jmp 0xf2ee
popq %rbx
popq %r14
popq %r15
jmp 0x4390
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CreateBrinkinfo(dclipnode_t const*, int)
void *CreateBrinkinfo (const dclipnode_t *clipnodes, int headnode)
{
	bbrinkinfo_t *info;
	try
	{
		hlassume (info = (bbrinkinfo_t *)malloc (sizeof (bbrinkinfo_t)), assume_NoMemory);
		ExpandClipnodes (info, clipnodes, headnode);
		BuildTreeCells (info);
		CollectBrinks (info);
		AnalyzeBrinks (info);
		FreeBrinks (info);
		DeleteTreeCells (info);
		SortPartitions (info);
	}
	catch (std::bad_alloc)
	{
		hlassume (false, assume_NoMemory);
	}
	return info;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x4410
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
pushq $0x1
popq %rsi
callq 0x92bb
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xdfe8
movq %rbx, %rdi
callq 0xe0b1
movq %rbx, %rdi
callq 0xe306
movq %rbx, %rdi
callq 0xebba
movq %rbx, %rdi
callq 0xe373
movq %rbx, %rdi
callq 0xe13d
movq %rbx, %rdi
callq 0xf33b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xf59f
movq %r14, %rdi
callq 0x43d0
movq 0x19a5f(%rip), %rax     # 0x28fc0
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x4130
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x92bb
leaq 0x8(%rsp), %rdi
callq 0x41c0
callq 0x4520
jmp 0xf53e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x41c0
callq 0x4520
movq %r14, %rdi
callq 0x4550
movq %rax, %rdi
callq 0xfaf1