LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rax
movb 0x7(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
je 0x133ad
leaq 0x265be(%rip), %rdi     # 0x3995b
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x10(%rsp), %rax
movb 0x7(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13260
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x19ec0
testb $0x1, %al
jne 0x13427
leaq 0x2657a(%rip), %rdi     # 0x39991
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x13451
movq (%rsp), %rdi
callq 0x19ee0
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x4300
movq 0x8(%rsp), %rdi
callq 0x4370
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19ef0
movq 0x50(%rsp), %rdi
callq 0x19f10
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x19f60
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x19f40
testb $0x1, %al
jne 0x134cd
jmp 0x13548
leaq 0x38(%rsp), %rdi
callq 0x19f90
movq (%rax), %rax
cmpq 0x48(%rsp), %rax
jne 0x13530
leaq 0x38(%rsp), %rdi
callq 0x19f90
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x47(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x13530
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1a000
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19fb0
movq %rax, 0x18(%rsp)
jmp 0x1355f
jmp 0x13532
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a020
movq %rax, 0x10(%rsp)
jmp 0x134a9
leaq 0x26473(%rip), %rdi     # 0x399c2
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1a050
testb $0x1, %al
jne 0x13607
leaq 0x263ff(%rip), %rdi     # 0x399f6
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x18(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0x13620
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x12050
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jge 0x1369b
movq 0x18(%rsp), %rdi
cmpl $0x0, 0x14(%rsp)
setne %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x131f0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
cmpl $0x0, 0x14(%rsp)
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x13360
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x19ec0
testb $0x1, %al
jne 0x1367d
jmp 0x1368c
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x133f0
jmp 0x1368e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x13628
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x136c5
movq (%rsp), %rdi
callq 0x1a070
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x4300
movq 0x18(%rsp), %rdi
callq 0x4370
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x13729
leaq 0x2630c(%rip), %rdi     # 0x39a25
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x10(%rsp), %rax
addq $0x10, %rax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movb 0x7(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
je 0x137a1
leaq 0x262c3(%rip), %rdi     # 0x39a54
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x8(%rsp), %rax
addq $0x10, %rax
movb 0x7(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13470
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x19d60
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0x19d80
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0x19dd0
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x19db0
testb $0x1, %al
jne 0x1384e
jmp 0x138f1
leaq 0x50(%rsp), %rdi
callq 0x19e00
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x19e00
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13470
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x19e70
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x19e20
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1a050
testb $0x1, %al
jne 0x138dd
jmp 0x138ec
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x135d0
jmp 0x13808
movl $0x0, 0x24(%rsp)
cmpl $0x2, 0x24(%rsp)
jge 0x13941
movq 0x58(%rsp), %rax
addq $0x10, %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x13932
leaq 0x26166(%rip), %rdi     # 0x39a88
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
jmp 0x13934
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x138f9
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1396a
movq (%rsp), %rdi
callq 0x19ee0
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x4300
movq 0x58(%rsp), %rdi
callq 0x4370
movq 0x60(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19ef0
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x19f10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x19f60
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19f40
testb $0x1, %al
jne 0x139eb
jmp 0x13a5e
leaq 0x30(%rsp), %rdi
callq 0x19f90
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19f90
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13750
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x13a59
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x13a59
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x137f0
jmp 0x139a8
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x13a87
movq (%rsp), %rdi
callq 0x1a070
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x4300
movq 0x38(%rsp), %rdi
callq 0x4370
movq 0x40(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x1616d
jmp 0x1621f
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x28(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x10(%rax), %r10
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movsd 0x23450(%rip), %xmm0    # 0x39600
leaq 0x18(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x13ab0
movq 0x28(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x16150
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x16150
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x3fff8, (%rax)        # imm = 0x3FFF8
jl 0x16262
leaq 0x239bf(%rip), %rdi     # 0x39c1a
movb $0x0, %al
callq 0xb510
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x1c(%rsp)
jge 0x162b4
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
jmp 0x16350
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,8), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movslq 0x4(%rax), %rax
leaq 0x20d974f(%rip), %rcx   # 0x20efa30
shlq $0x6, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x1634e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movswl 0x4(%rax,%rcx,2), %ecx
callq 0x16230
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x162f9
jmp 0x16350
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl $0xdffe40, %edi         # imm = 0xDFFE40
callq 0x43e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x16230
movq 0x30(%rsp), %rax
movslq (%rax), %rax
imulq $0x38, %rax, %rdi
callq 0x43e0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rax
movslq (%rax), %rax
imulq $0x38, %rax, %rdx
callq 0x4260
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x164c3
movl $0x0, 0x10(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x164b1
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl $0x38, %ecx
cqto
idivq %rcx
movq 0x8(%rsp), %rdx
imulq $0x38, %rax, %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x16437
jmp 0x164b3
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1641e
movq 0x18(%rsp), %rdi
callq 0x4370
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x12be0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x18(%rax), %rdx
movsd 0x230e0(%rip), %xmm0    # 0x39608
callq 0x12c20
movq %rax, %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x16150
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1659a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x13990
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
jne 0x165ca
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x16560
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x16560
addq $0x18, %rsp
retq
nop
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x13990
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x16560
movq (%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1662c
leaq 0x23627(%rip), %rdi     # 0x39c43
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
popq %rax
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, (%rax)
je 0x16739
leaq 0x38(%rsp), %rdi
callq 0x19ef0
leaq 0x30(%rsp), %rdi
callq 0x19d60
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x19f10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x19f60
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19f40
testb $0x1, %al
jne 0x166a9
jmp 0x16737
leaq 0x38(%rsp), %rdi
callq 0x19f90
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19d80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19f90
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19dd0
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19db0
testb $0x1, %al
jne 0x166fc
jmp 0x16720
leaq 0x30(%rsp), %rdi
callq 0x19e00
movq (%rax), %rax
movb $0x0, 0x38(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x19e90
movq %rax, 0x8(%rsp)
jmp 0x166cd
jmp 0x16722
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x1a020
movq %rax, (%rsp)
jmp 0x1667b
jmp 0x16755
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x16630
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x16630
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x16630
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rsi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x16760
movq (%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x43e0
movq (%rsp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x16630
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rsi
addq $0x20, %rsi
movq (%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x16760
popq %rax
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm2
leaq 0x2253d(%rip), %rdi     # 0x39cea
movb $0x3, %al
callq 0xb060
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x20(%rsp), %rax
movsd 0x20(%rax), %xmm1
movq 0x20(%rsp), %rax
movsd 0x28(%rax), %xmm2
leaq 0x22520(%rip), %rdi     # 0x39cf9
movb $0x3, %al
callq 0xb060
movq 0x20(%rsp), %rax
movl 0x30(%rax), %esi
movq 0x20(%rsp), %rax
movl 0x34(%rax), %edx
leaq 0x22517(%rip), %rdi     # 0x39d0e
movb $0x0, %al
callq 0xb060
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x17916
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
cmpl 0x30(%rcx,%rdx,4), %eax
jge 0x17904
movq 0x20(%rsp), %rax
addq $0x38, %rax
movslq 0x1c(%rsp), %rcx
imulq $0x600, %rcx, %rcx      # imm = 0x600
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq $0xc38, %rax            # imm = 0xC38
movslq 0x1c(%rsp), %rcx
imulq $0xc00, %rcx, %rcx      # imm = 0xC00
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
movb 0x1c(%rax), %al
andb $0x1, %al
movzbl %al, %r8d
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm2
leaq 0x22458(%rip), %rdi     # 0x39d1f
movb $0x3, %al
callq 0xb060
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x10(%rsp), %rax
movl (%rax), %r8d
leaq 0x2246a(%rip), %rdi     # 0x39d57
movb $0x0, %al
callq 0xb060
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x17819
jmp 0x17906
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x17806
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x18d1d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
testb $0x1, (%rax)
jne 0x18cba
jmp 0x18d0d
jmp 0x18cbc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x18d0b
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rdi
callq 0x4370
jmp 0x18cbc
jmp 0x18d0d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x18c91
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4370
addq $0x18, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x30, %edi
callq 0x43e0
movq %rax, 0x20(%rsp)
testq %rax, %rax
setne %al
movzbl %al, %edi
movl $0x1, %esi
callq 0xbe90
jmp 0x19031
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x16360
jmp 0x19046
movq 0x20(%rsp), %rdi
callq 0x164e0
jmp 0x19052
movq 0x20(%rsp), %rdi
callq 0x169d0
jmp 0x1905e
movq 0x20(%rsp), %rdi
callq 0x17c10
jmp 0x1906a
movq 0x20(%rsp), %rdi
callq 0x16a70
movq 0x20(%rsp), %rdi
callq 0x165d0
jmp 0x19080
movq 0x20(%rsp), %rdi
callq 0x18d30
jmp 0x1908c
jmp 0x190ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x19115
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x43b0
movq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1a5d0
movq (%rsp), %rdi
callq 0x4130
xorl %edi, %edi
movl $0x1, %esi
callq 0xbe90
jmp 0x190db
leaq 0x8(%rsp), %rdi
callq 0x41c0
callq 0x44f0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x41c0
callq 0x44f0
jmp 0x19113
jmp 0x19115
movq 0x18(%rsp), %rdi
callq 0x4520
movq %rax, %rdi
callq 0x1a610
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: FixBrinks(void const*, bbrinklevel_e, int&, dclipnode_t*, int, int, int&)
bool FixBrinks (const void *brinkinfo, bbrinklevel_e level, int &headnode_out, dclipnode_t *clipnodes_out, int maxsize, int size, int &size_out)
{
	const bbrinkinfo_t *info = (const bbrinkinfo_t *)brinkinfo;
	dclipnode_t *begin = clipnodes_out;
	dclipnode_t *end = &clipnodes_out[maxsize];
	dclipnode_t *current = &clipnodes_out[size];
#ifdef HLBSP_MERGECLIPNODE
	clipnodemap_t outputmap;
#endif
	int r;
	if (!FixBrinks_r (&info->clipnodes[0], level, r, begin, end, current
#ifdef HLBSP_MERGECLIPNODE
		, &outputmap
#endif
		))
	{
		return false;
	}
	headnode_out = r;
	size_out = current - begin;
	return true;
}

// Assembly:
subq $0xb8, %rsp
movq 0xc0(%rsp), %rax
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movl %r8d, 0x8c(%rsp)
movl %r9d, 0x88(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x90(%rsp), %rax
movslq 0x8c(%rsp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rax
movslq 0x88(%rsp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x68(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1a840
movq 0x10(%rsp), %rdx
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xa4(%rsp), %esi
movq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
movq %rsp, %rax
movq %rdx, (%rax)
leaq 0x34(%rsp), %rdx
leaq 0x68(%rsp), %r9
callq 0x194e0
movb %al, 0x1f(%rsp)
jmp 0x19959
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1998f
jmp 0x19963
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x199ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1a850
jmp 0x199e5
movl 0x34(%rsp), %ecx
movq 0x98(%rsp), %rax
movl %ecx, (%rax)
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %ecx
movq 0xc0(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1a850
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4520
nop
// File: FreeSlave[P]vhlt/hlbsp/merge.cpp
// Function: MergePlaneFaces(surface_s*)
void            MergePlaneFaces(surface_t* plane)
{
    face_t*         f1;
    face_t*         next;
    face_t*         merged;

    merged = NULL;

    for (f1 = plane->faces; f1; f1 = next)
    {
        next = f1->next;
        merged = MergeFaceToList(f1, merged);
    }

    // chain all of the non-empty faces to the plane
    plane->faces = FreeMergeListScraps(merged);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x20825
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x20840
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x207f0
movq 0x8(%rsp), %rdi
callq 0x208e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x48(%rax)
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/hlbsp/merge.cpp
// Function: MergeFaceToList(face_s*, face_s*)
static face_t*  MergeFaceToList(face_t* face, face_t* list)
{
    face_t*         newf;
    face_t*         f;

    for (f = list; f; f = f->next)
    {
        //CheckColinear (f);            
        newf = TryMerge(face, f);
        if (!newf)
        {
            continue;
        }
        FreeFace(face);
        f->numpoints = -1;                                 // merged out
        return MergeFaceToList(newf, list);
    }

    // didn't merge, so add at start
    face->next = list;
    return face;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x208b3
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x209f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2087b
jmp 0x208a6
movq 0x18(%rsp), %rdi
callq 0x24f00
movq (%rsp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20840
movq %rax, 0x20(%rsp)
jmp 0x208ca
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x20857
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/merge.cpp
// Function: FreeMergeListScraps(face_s*)
static face_t*  FreeMergeListScraps(face_t* merged)
{
    face_t*         head;
    face_t*         next;

    head = NULL;
    for (; merged; merged = next)
    {
        next = merged->next;
        if (merged->numpoints == -1)
        {
            FreeFace(merged);
        }
        else
        {
            merged->next = head;
            head = merged;
        }
    }

    return head;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x20941
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x2c(%rax)
jne 0x2091d
movq 0x10(%rsp), %rdi
callq 0x24f00
jmp 0x20934
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x20936
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x208f2
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/merge.cpp
// Function: MergeAll(surface_s*)
void            MergeAll(surface_t* surfhead)
{
    surface_t*      surf;
    int             mergefaces;
    face_t*         f;

    Verbose("---- MergeAll ----\n");

    mergefaces = 0;
    for (surf = surfhead; surf; surf = surf->next)
    {
        MergePlaneFaces(surf);
        for (f = surf->faces; f; f = f->next)
        {
            mergefaces++;
        }
    }

    Verbose("%i mergefaces\n", mergefaces);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x1967f(%rip), %rdi     # 0x39fdf
movb $0x0, %al
callq 0xba90
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x209cc
movq 0x18(%rsp), %rdi
callq 0x207d0
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x209bb
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x20999
jmp 0x209bd
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x20979
movl 0x14(%rsp), %esi
leaq 0x1961c(%rip), %rdi     # 0x39ff3
movb $0x0, %al
callq 0xba90
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: isClassnameAllowableOutside(char const*)
bool            isClassnameAllowableOutside(const char* const classname)
{
    if (g_strAllowableOutsideList)
    {
        unsigned        x;
        char**          list = g_strAllowableOutsideList;

        for (x = 0; x < g_nAllowableOutside; x++, list++)
        {
            if (list)
            {
                if (!strcasecmp(classname, *list))
                {
                    return true;
                }
            }
        }
    }

    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x20c92cf(%rip)   # 0x20ea8f0
je 0x2168a
movq 0x20c92c6(%rip), %rax   # 0x20ea8f0
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20c92a7(%rip), %eax   # 0x20ea8e8
jae 0x21688
cmpq $0x0, 0x8(%rsp)
je 0x2166b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x4320
cmpl $0x0, %eax
jne 0x21669
movb $0x1, 0x27(%rsp)
jmp 0x2168f
jmp 0x2166b
jmp 0x2166d
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x21637
jmp 0x2168a
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: PlaceOccupant(int, double const*, node_s*)
static bool     PlaceOccupant(const int num, const vec3_t point, node_t* headnode)
{
    node_t*         n;

    n = PointInLeaf(headnode, point);
    if (n->contents == CONTENTS_SOLID)
    {
        return false;
    }
    //Log("PlaceOccupant::n->contents == %i\n", n->contents);

    n->occupied = num;
    return true;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x225a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
jne 0x21e5b
movb $0x0, 0x27(%rsp)
jmp 0x21e6f
movl 0x20(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc0(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: RecursiveFillOutside(node_s*, bool)
static bool     RecursiveFillOutside(node_t* l, const bool fill)
{
    portal_t*       p;
    int             s;

    if ((l->contents == CONTENTS_SOLID) || (l->contents == CONTENTS_SKY) 
#ifdef ZHLT_DETAIL
        || (l->contents == CONTENTS_DETAIL)
#endif
        )
	{
        /*if (l->contents != CONTENTS_SOLID)
            Log("RecursiveFillOutside::l->contents == %i \n", l->contents);*/

        return false;
    }

    if (l->valid == valid)
    {
        return false;
    }

    if (l->occupied)
    {
        hit_occupied = l->occupied;
        backdraw = 1000;
        return true;
    }

    l->valid = valid;

    // fill it and it's neighbors
    if (fill)
    {
#ifdef ZHLT_DETAILBRUSH
		FillLeaf (l);
#else
        l->contents = CONTENTS_SOLID;
        l->planenum = -1;
#endif
    }
    outleafs++;

    for (p = l->portals; p;)
    {
        s = (p->nodes[0] == l);

        if (RecursiveFillOutside(p->nodes[s], fill))
        {                                                  // leaked, so stop filling
            if (backdraw-- > 0)
            {
                MarkLeakTrail(p);
            }
            return true;
        }
        p = p->next[!s];
    }

    return false;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
je 0x21eae
movq 0x18(%rsp), %rax
cmpl $-0x6, 0xa0(%rax)
jne 0x21eb8
movb $0x0, 0x27(%rsp)
jmp 0x21fe4
movq 0x18(%rsp), %rax
movl 0xbc(%rax), %eax
cmpl 0x20c8a33(%rip), %eax   # 0x20ea8fc
jne 0x21ed5
movb $0x0, 0x27(%rsp)
jmp 0x21fe4
movq 0x18(%rsp), %rax
cmpl $0x0, 0xc0(%rax)
je 0x21f08
movq 0x18(%rsp), %rax
movl 0xc0(%rax), %eax
movl %eax, 0x20c8a24(%rip)   # 0x20ea918
movl $0x3e8, 0x20c8a2a(%rip) # imm = 0x3E8
movb $0x1, 0x27(%rsp)
jmp 0x21fe4
movl 0x20c89ee(%rip), %ecx   # 0x20ea8fc
movq 0x18(%rsp), %rax
movl %ecx, 0xbc(%rax)
testb $0x1, 0x17(%rsp)
je 0x21f2a
movq 0x18(%rsp), %rdi
callq 0x22410
movl 0x20c89c8(%rip), %eax   # 0x20ea8f8
addl $0x1, %eax
movl %eax, 0x20c89bf(%rip)   # 0x20ea8f8
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x21fdf
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x18(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq 0x48(%rax,%rcx,8), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x21e80
testb $0x1, %al
jne 0x21f93
jmp 0x21fba
movl 0x20c898f(%rip), %eax   # 0x20ea928
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x20c8984(%rip)   # 0x20ea928
cmpl $0x0, %eax
jle 0x21fb3
movq 0x8(%rsp), %rdi
callq 0x226d0
movb $0x1, 0x27(%rsp)
jmp 0x21fe4
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rsp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movq 0x58(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x21f4a
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: MarkOccupied_r(node_s*)
void			MarkOccupied_r (node_t* node)
{
	if (node->empty == 1)
	{
		node->empty = 0;
		portal_t*       p;
		int             s;
		for (p = node->portals; p; p = p->next[!s])
		{
			s = (p->nodes[0] == node);
			MarkOccupied_r (p->nodes[s]);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1, 0xc4(%rax)
jne 0x223b1
movq 0x10(%rsp), %rax
movl $0x0, 0xc4(%rax)
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x223af
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x10(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq 0x48(%rax,%rcx,8), %rdi
callq 0x22320
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rsp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movq 0x58(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x22357
jmp 0x223b1
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: FillLeaf(node_s*)
static void FillLeaf (node_t *l)
{
	if (!l->isportalleaf)
	{
		Warning ("FillLeaf: not leaf");
		return;
	}
	if (l->contents == CONTENTS_SOLID)
	{
		Warning ("FillLeaf: fill solid");
		return;
	}
	FreeDetailNode_r (l);
	l->contents = CONTENTS_SOLID;
	l->planenum = -1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x49(%rax)
jne 0x2242f
leaq 0x18024(%rip), %rdi     # 0x3a44a
movb $0x0, %al
callq 0xb980
jmp 0x22471
movq (%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
jne 0x2244c
leaq 0x1801a(%rip), %rdi     # 0x3a45d
movb $0x0, %al
callq 0xb980
jmp 0x22471
movq (%rsp), %rdi
callq 0x22930
movq (%rsp), %rax
movl $0xfffffffe, 0xa0(%rax) # imm = 0xFFFFFFFE
movq (%rsp), %rax
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: FillInside(node_s*)
void			FillInside (node_t* node)
{
	int i;
	g_outside_node.empty = 0;
	ResetMark_r (node);
    for (i = 1; i < g_numentities; i++)
    {
		if (*ValueForKey(&g_entities[i], "origin"))
		{
			vec3_t origin;
			node_t* innode;
			GetVectorForKey(&g_entities[i], "origin", origin);
			origin[2] += 1;
			innode = PointInLeaf (node, origin);
			MarkOccupied_r (innode);
			origin[2] -= 2;
			innode = PointInLeaf (node, origin);
			MarkOccupied_r (innode);
		}
	}
	RemoveUnused_r (node);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x20c84a0(%rip), %rax   # 0x20ea930
movl $0x0, 0xc4(%rax)
movq 0x30(%rsp), %rdi
callq 0x222b0
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
leaq 0x201af3d(%rip), %rcx   # 0x203d3f4
cmpl (%rcx), %eax
jge 0x22585
movslq 0x2c(%rsp), %rax
leaq 0x201af35(%rip), %rdi   # 0x203d400
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x14159(%rip), %rsi     # 0x36632
callq 0x7cd0
cmpb $0x0, (%rax)
je 0x22573
movslq 0x2c(%rsp), %rax
leaq 0x201af0d(%rip), %rdi   # 0x203d400
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rdx
leaq 0x1412c(%rip), %rsi     # 0x36632
callq 0x8ba0
movsd 0x16c35(%rip), %xmm0    # 0x39148
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x225a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x22320
movsd 0x20(%rsp), %xmm0
movsd 0x17abd(%rip), %xmm1    # 0x3a008
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x225a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x22320
jmp 0x22575
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x224ac
movq 0x30(%rsp), %rdi
callq 0x223c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: PointInLeaf(node_s*, double const*)
static node_t*  PointInLeaf(node_t* node, const vec3_t point)
{
    vec_t           d;

#ifdef ZHLT_DETAILBRUSH
	if (node->isportalleaf)
#else
    if (node->contents)
#endif
    {
        //Log("PointInLeaf::node->contents == %i\n", node->contents);
        return node;
    }

    d = DotProduct(g_dplanes[node->planenum].normal, point) - g_dplanes[node->planenum].dist;

    if (d > 0)
        return PointInLeaf(node->children[0], point);

    return PointInLeaf(node->children[1], point);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x49(%rax)
je 0x225c8
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x226bd
movq 0x18(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20cd455(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movq 0x10(%rsp), %rax
movsd (%rax), %xmm2
movq 0x18(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20cd42e(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x18(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20cd3fd(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20cd3cc(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
subsd 0x30(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x226a2
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x225a0
movq %rax, 0x20(%rsp)
jmp 0x226bd
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x225a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)