LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: MarkLeakTrail(portal_s*)
static void     MarkLeakTrail(portal_t* n2)
{
    int             i;
    vec3_t          p1, p2, dir;
    float           len;
    portal_t*       n1;

    n1 = prevleaknode;
    prevleaknode = n2;

    if (!n1)
    {
        return;
    }

#ifdef HLBSP_MarkLeakTrail_FIX
    n1->winding->getCenter(p1);
    n2->winding->getCenter(p2);
#else
    n2->winding->getCenter(p1);
    n1->winding->getCenter(p2);
#endif

    // Linefile
    fprintf(linefile, "%f %f %f - %f %f %f\n", p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);

    // Pointfile
    fprintf(pointfile, "%f %f %f\n", p1[0], p1[1], p1[2]);

    VectorSubtract(p2, p1, dir);
    len = VectorLength(dir);
    VectorNormalize(dir);

    while (len > 2)
    {
        fprintf(pointfile, "%f %f %f\n", p1[0], p1[1], p1[2]);
        for (i = 0; i < 3; i++)
            p1[i] += dir[i] * 2;
        len -= 2;
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x20c8220(%rip), %rax   # 0x20ea900
movq %rax, (%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20c8210(%rip)   # 0x20ea900
cmpq $0x0, (%rsp)
jne 0x226fc
jmp 0x2289f
movq (%rsp), %rax
movq 0x68(%rax), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe030
movq 0x70(%rsp), %rax
movq 0x68(%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe030
movq 0x20c81e8(%rip), %rdi   # 0x20ea910
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
movsd 0x30(%rsp), %xmm3
movsd 0x38(%rsp), %xmm4
movsd 0x40(%rsp), %xmm5
leaq 0x17ce2(%rip), %rsi     # 0x3a435
movb $0x6, %al
callq 0x4420
movq 0x20c81a7(%rip), %rdi   # 0x20ea908
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
leaq 0x17cc6(%rip), %rsi     # 0x3a440
movb $0x3, %al
callq 0x4420
movsd 0x30(%rsp), %xmm0
subsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x40(%rsp), %xmm0
subsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4240
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x11bc0
movss 0xc(%rsp), %xmm0
movss 0x13836(%rip), %xmm1    # 0x36048
ucomiss %xmm1, %xmm0
jbe 0x2289f
movq 0x20c80e6(%rip), %rdi   # 0x20ea908
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
leaq 0x17c05(%rip), %rsi     # 0x3a440
movb $0x3, %al
callq 0x4420
movl $0x0, 0x6c(%rsp)
cmpl $0x3, 0x6c(%rsp)
jge 0x22882
movslq 0x6c(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
movslq 0x6c(%rsp), %rax
movsd 0x50(%rsp,%rax,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp,%rax,8)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x2284a
movss 0xc(%rsp), %xmm0
movss 0x137b8(%rip), %xmm1    # 0x36048
subss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x22804
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: MarkFacesInside_r(node_s*)
static void MarkFacesInside_r (node_t *node)
{
	if (node->planenum == -1)
	{
		face_t **fp;
		for (fp = node->markfaces; *fp; fp++)
		{
	        (*fp)->outputnumber = 0;
		}
	}
	else
	{
		MarkFacesInside_r (node->children[0]);
		MarkFacesInside_r (node->children[1]);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x22904
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x22902
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x228d8
jmp 0x22926
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x228b0
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x228b0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/outside.cpp
// Function: FreeDetailNode_r(node_s*)
static void FreeDetailNode_r (node_t *n)
{
	int i;
	if (n->planenum == -1)
	{
		if (!(n->isportalleaf && n->contents == CONTENTS_SOLID))
		{
			free (n->markfaces);
			n->markfaces = NULL;
		}
		return;
	}
	for (i = 0; i < 2; i++)
	{
		FreeDetailNode_r (n->children[i]);
		free (n->children[i]);
		n->children[i] = NULL;
	}
	face_t *f, *next;
	for (f = n->faces; f; f = next)
	{
		next = f->next;
		FreeFace (f);
	}
	n->faces = NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x22986
movq 0x20(%rsp), %rax
testb $0x1, 0x49(%rax)
je 0x22960
movq 0x20(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
je 0x22981
movq 0x20(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x4370
movq 0x20(%rsp), %rax
movq $0x0, 0xa8(%rax)
jmp 0x22a32
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x229e6
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq 0x88(%rax,%rcx,8), %rdi
callq 0x22930
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq 0x88(%rax,%rcx,8), %rdi
callq 0x4370
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq $0x0, 0x88(%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2298e
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x22a22
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x24f00
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x229f7
movq 0x20(%rsp), %rax
movq $0x0, 0x98(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: AddPortalToNodes(portal_s*, node_s*, node_s*)
void            AddPortalToNodes(portal_t* p, node_t* front, node_t* back)
{
    if (p->nodes[0] || p->nodes[1])
    {
        Error("AddPortalToNode: allready included");
    }

    p->nodes[0] = front;
    p->next[0] = front->portals;
    front->portals = p;

    p->nodes[1] = back;
    p->next[1] = back->portals;
    back->portals = p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x22a6a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x22a78
leaq 0x17a27(%rip), %rdi     # 0x3a498
movb $0x0, %al
callq 0xb510
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq (%rsp), %rax
movq 0xb0(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0xb0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: RemovePortalFromNode(portal_s*, node_s*)
void            RemovePortalFromNode(portal_t* portal, node_t* l)
{
    portal_t**      pp;
    portal_t*       t;

    // remove reference to the current portal
    pp = &l->portals;
    while (1)
    {
        t = *pp;
        if (!t)
        {
            Error("RemovePortalFromNode: portal not in leaf");
        }

        if (t == portal)
        {
            break;
        }

        if (t->nodes[0] == l)
        {
            pp = &t->next[0];
        }
        else if (t->nodes[1] == l)
        {
            pp = &t->next[1];
        }
        else
        {
            Error("RemovePortalFromNode: portal not bounding leaf");
        }
    }

    if (portal->nodes[0] == l)
    {
        *pp = portal->next[0];
        portal->nodes[0] = NULL;
    }
    else if (portal->nodes[1] == l)
    {
        *pp = portal->next[1];
        portal->nodes[1] = NULL;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x22b31
leaq 0x17991(%rip), %rdi     # 0x3a4bb
movb $0x0, %al
callq 0xb510
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x22b3f
jmp 0x22b98
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x22b5f
movq 0x8(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x10(%rsp)
jmp 0x22b93
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x22b83
movq 0x8(%rsp), %rax
addq $0x58, %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x22b91
leaq 0x1795a(%rip), %rdi     # 0x3a4e4
movb $0x0, %al
callq 0xb510
jmp 0x22b93
jmp 0x22b0e
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x22bc8
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x48(%rax)
jmp 0x22bf8
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x22bf6
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x50(%rax)
jmp 0x22bf8
addq $0x28, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: WritePortalfile(node_s*)
void            WritePortalfile(node_t* headnode)
{
    // set the visleafnum field in every leaf and count the total number of portals
    num_visleafs = 0;
    num_visportals = 0;
    NumberLeafs_r(headnode);

    // write the file
    pf = fopen(g_portfilename, "w");
    if (!pf)
    {
        Error("Error writing portal file %s", g_portfilename);
    }
#ifdef HLBSP_VIEWPORTAL
	if (g_viewportal)
	{
		char filename[_MAX_PATH];
		safe_snprintf(filename, _MAX_PATH, "%s_portal.pts", g_Mapname);
		pf_view = fopen (filename, "w");
		if (!pf_view)
		{
			Error ("Couldn't open %s", filename);
		}
		Log ("Writing '%s' ...\n", filename);
	}
#endif

    fprintf(pf, "%i\n", num_visleafs);
    fprintf(pf, "%i\n", num_visportals);

#ifdef ZHLT_DETAILBRUSH
	WriteLeafCount_r (headnode);
#endif
    WritePortalFile_r(headnode);
    fclose(pf);
#ifdef HLBSP_VIEWPORTAL
	if (g_viewportal)
	{
		fclose (pf_view);
	}
#endif
    Log("BSP generation successful, writing portal file '%s'\n", g_portfilename);
}

// Assembly:
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, 0x1000(%rsp)
movl $0x0, 0x20c7a4f(%rip)   # 0x20ea9f8
movl $0x0, 0x20c7a49(%rip)   # 0x20ea9fc
movq 0x1000(%rsp), %rdi
callq 0x23100
leaq 0x20caa59(%rip), %rdi   # 0x20eda20
leaq 0x1831c(%rip), %rsi     # 0x3b2ea
callq 0x4360
movq %rax, 0x20c7a26(%rip)   # 0x20eaa00
cmpq $0x0, 0x20c7a1e(%rip)   # 0x20eaa00
jne 0x22ff9
leaq 0x17528(%rip), %rdi     # 0x3a513
leaq 0x20caa2e(%rip), %rsi   # 0x20eda20
movb $0x0, %al
callq 0xb510
leaq 0x20cca2b(%rip), %rax   # 0x20efa2b
testb $0x1, (%rax)
je 0x23064
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
leaq 0x1751c(%rip), %rdx     # 0x3a530
leaq 0x232f5(%rip), %rcx     # 0x46310
movb $0x0, %al
callq 0x9470
movq %rsp, %rdi
leaq 0x182be(%rip), %rsi     # 0x3b2ea
callq 0x4360
movq %rax, 0x20c79d0(%rip)   # 0x20eaa08
cmpq $0x0, 0x20c79c8(%rip)   # 0x20eaa08
jne 0x23053
movq %rsp, %rsi
leaq 0x174f2(%rip), %rdi     # 0x3a53e
movb $0x0, %al
callq 0xb510
movq %rsp, %rsi
leaq 0x174f2(%rip), %rdi     # 0x3a54f
movb $0x0, %al
callq 0xb060
movq 0x20c7995(%rip), %rdi   # 0x20eaa00
movl 0x20c7987(%rip), %edx   # 0x20ea9f8
leaq 0x160b5(%rip), %rsi     # 0x3912d
movb $0x0, %al
callq 0x4420
movq 0x20c797a(%rip), %rdi   # 0x20eaa00
movl 0x20c7970(%rip), %edx   # 0x20ea9fc
leaq 0x1609a(%rip), %rsi     # 0x3912d
movb $0x0, %al
callq 0x4420
movq 0x1000(%rsp), %rdi
callq 0x23210
movq 0x1000(%rsp), %rdi
callq 0x23290
movq 0x20c7945(%rip), %rdi   # 0x20eaa00
callq 0x42e0
leaq 0x20cc964(%rip), %rax   # 0x20efa2b
testb $0x1, (%rax)
je 0x230d8
movq 0x20c7935(%rip), %rdi   # 0x20eaa08
callq 0x42e0
leaq 0x17482(%rip), %rdi     # 0x3a561
leaq 0x20ca93a(%rip), %rsi   # 0x20eda20
movb $0x0, %al
callq 0xb060
addq $0x1008, %rsp           # imm = 0x1008
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: NumberLeafs_r(node_s*)
static void     NumberLeafs_r(node_t* node)
{
    portal_t*       p;

#ifdef ZHLT_DETAILBRUSH
	if (!node->isportalleaf)
#else
    if (!node->contents)
#endif
    {                                                      // decision node
        node->visleafnum = -99;
        NumberLeafs_r(node->children[0]);
        NumberLeafs_r(node->children[1]);
        return;
    }

    if (node->contents == CONTENTS_SOLID)
    {                                                      // solid block, viewpoint never inside
        node->visleafnum = -1;
        return;
    }

    node->visleafnum = num_visleafs++;

    for (p = node->portals; p;)
    {
        if (p->nodes[0] == node)                           // only write out from first leaf
        {
            if (p->nodes[0]->contents == p->nodes[1]->contents)
            {
                num_visportals++;
            }
            p = p->next[0];
        }
        else
        {
            p = p->next[1];
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x49(%rax)
jne 0x2314a
movq 0x10(%rsp), %rax
movl $0xffffff9d, 0xb8(%rax) # imm = 0xFFFFFF9D
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x23100
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x23100
jmp 0x23200
movq 0x10(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
jne 0x2316c
movq 0x10(%rsp), %rax
movl $0xffffffff, 0xb8(%rax) # imm = 0xFFFFFFFF
jmp 0x23200
movl 0x20c7886(%rip), %ecx   # 0x20ea9f8
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x20c787b(%rip)   # 0x20ea9f8
movq 0x10(%rsp), %rax
movl %ecx, 0xb8(%rax)
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x23200
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x231f0
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movl 0xa0(%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
cmpl 0xa0(%rcx), %eax
jne 0x231e0
movl 0x20c7825(%rip), %eax   # 0x20ea9fc
addl $0x1, %eax
movl %eax, 0x20c781c(%rip)   # 0x20ea9fc
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x231fe
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x23199
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: WriteLeafCount_r(node_s*)
static void WriteLeafCount_r (node_t *node)
{
	if (!node->isportalleaf)
	{
		WriteLeafCount_r (node->children[0]);
		WriteLeafCount_r (node->children[1]);
	}
	else
	{
		if (node->contents == CONTENTS_SOLID)
		{
			return;
		}
		int count = CountChildLeafs_r (node);
		fprintf (pf, "%i\n", count);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x49(%rax)
jne 0x23248
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x23210
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x23210
jmp 0x2327f
movq 0x10(%rsp), %rax
cmpl $-0x2, 0xa0(%rax)
jne 0x23258
jmp 0x2327f
movq 0x10(%rsp), %rdi
callq 0x23a00
movl %eax, 0xc(%rsp)
movq 0x20c7793(%rip), %rdi   # 0x20eaa00
movl 0xc(%rsp), %edx
leaq 0x15eb5(%rip), %rsi     # 0x3912d
movb $0x0, %al
callq 0x4420
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: FreePortals(node_s*)
void            FreePortals(node_t* node)
{
    portal_t*       p;
    portal_t*       nextp;

#ifdef ZHLT_DETAILBRUSH
	if (!node->isportalleaf)
#else
    if (node->planenum != -1)
#endif
    {
        FreePortals(node->children[0]);
        FreePortals(node->children[1]);
        return;
    }

    for (p = node->portals; p; p = nextp)
    {
        if (p->nodes[0] == node)
        {
            nextp = p->next[0];
        }
        else
        {
            nextp = p->next[1];
        }
        RemovePortalFromNode(p, p->nodes[0]);
        RemovePortalFromNode(p, p->nodes[1]);
        delete p->winding;
        FreePortal(p);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x49(%rax)
jne 0x2394b
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x23910
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x23910
jmp 0x239f4
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x239f4
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x23988
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x23996
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x22af0
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rsi
callq 0x22af0
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x239db
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x24f80
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2395c
addq $0x28, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/portals.cpp
// Function: CountChildLeafs_r(node_s*)
static int CountChildLeafs_r (node_t *node)
{
	if (node->planenum == -1)
	{ // dleaf
		if (node->iscontentsdetail)
		{ // solid
			return 0;
		}
		else
		{
			return 1;
		}
	}
	else
	{ // node
		int count = 0;
		count += CountChildLeafs_r (node->children[0]);
		count += CountChildLeafs_r (node->children[1]);
		return count;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $-0x1, 0x80(%rax)
jne 0x23a36
movq 0x8(%rsp), %rax
testb $0x1, 0x4a(%rax)
je 0x23a2c
movl $0x0, 0x14(%rsp)
jmp 0x23a78
movl $0x1, 0x14(%rsp)
jmp 0x23a78
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x23a00
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x23a00
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: NewFaceFromFace(face_s const*)
face_t*         NewFaceFromFace(const face_t* const in)
{
    face_t*         newf;

    newf = AllocFace();

    newf->planenum = in->planenum;
    newf->texturenum = in->texturenum;
    newf->original = in->original;
    newf->contents = in->contents;
#ifdef HLBSP_NewFaceFromFace_FIX
	newf->facestyle = in->facestyle;
#endif
#ifdef ZHLT_DETAILBRUSH
	newf->detaillevel = in->detaillevel;
#endif

    return newf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x23df0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: AllocFace()
face_t*         AllocFace()
{
    face_t*         f;

    f = (face_t*)malloc(sizeof(face_t));
    memset(f, 0, sizeof(face_t));

    f->planenum = -1;

    return f;
}

// Assembly:
pushq %rax
movl $0x4b8, %edi            # imm = 0x4B8
callq 0x43e0
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x4b8, %edx            # imm = 0x4B8
callq 0x4180
movq (%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
popq %rcx
retq
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: FreeSide(side_s*)
void FreeSide (side_t *s)
{
	if (s->w)
	{
		delete s->w;
	}
	free (s);
	return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x24ff6
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x24ff4
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x24ff6
movq 0x10(%rsp), %rdi
callq 0x4370
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: NewSideFromSide(side_s const*)
side_t *NewSideFromSide (const side_t *s)
{
	side_t *news;
	news = AllocSide ();
	news->plane = s->plane;
	news->w = new Winding (*s->w);
	return news;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x24f90
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movups 0x8(%rcx), %xmm0
movups 0x18(%rcx), %xmm1
movups 0x28(%rcx), %xmm2
movups 0x38(%rcx), %xmm3
movups %xmm3, 0x38(%rax)
movups %xmm2, 0x28(%rax)
movups %xmm1, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movl $0x20, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0xea90
jmp 0x25071
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x20, %esi
callq 0x4300
movq 0x10(%rsp), %rdi
callq 0x4520
nop
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: FreeBrush(brush_s*)
void FreeBrush (brush_t *b)
{
	if (b->sides)
	{
		side_t *s, *next;
		for (s = b->sides; s; s = next)
		{
			next = s->next;
			FreeSide (s);
		}
	}
	free (b);
	return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2512e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2512c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x24fc0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x25103
jmp 0x2512e
movq 0x10(%rsp), %rdi
callq 0x4370
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: NewBrushFromBrush(brush_s const*)
brush_t *NewBrushFromBrush (const brush_t *b)
{
	brush_t *newb;
	newb = AllocBrush ();
	side_t *s, **pnews;
	for (s = b->sides, pnews = &newb->sides; s; s = s->next, pnews = &(*pnews)->next)
	{
		*pnews = NewSideFromSide (s);
	}
	return newb;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x250b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x251a8
movq 0x10(%rsp), %rdi
callq 0x25010
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2516f
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: ClipBrush(brush_s**, plane_t const*, double)
void ClipBrush (brush_t **b, const dplane_t *split, vec_t epsilon)
{
	side_t *s, **pnext;
	Winding *w;
	for (pnext = &(*b)->sides, s = *pnext; s; s = *pnext)
	{
		if (s->w->Clip (*split, false, epsilon))
		{
			pnext = &s->next;
		}
		else
		{
			*pnext = s->next;
			FreeSide (s);
		}
	}
	if (!(*b)->sides)
	{ // empty brush
		FreeBrush (*b);
		*b = NULL;
		return;
	}
	w = new Winding (*split);
	for (s = (*b)->sides; s; s = s->next)
	{
		if (!w->Clip (s->plane, false, epsilon))
		{
			break;
		}
	}
	if (w->m_NumPoints == 0)
	{
		delete w;
	}
	else
	{
		s = AllocSide ();
		s->plane = *split;
		s->w = w;
		s->next = (*b)->sides;
		(*b)->sides = s;
	}
	return;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x25252
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
xorl %edx, %edx
callq 0x105e0
testb $0x1, %al
jne 0x2521b
jmp 0x25227
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x25241
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
callq 0x24fc0
jmp 0x25243
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x251f2
movq 0x50(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2527f
movq 0x50(%rsp), %rax
movq (%rax), %rdi
callq 0x250e0
movq 0x50(%rsp), %rax
movq $0x0, (%rax)
jmp 0x25396
movl $0x20, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rsi
callq 0xf740
jmp 0x252a0
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x25317
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
movsd 0x40(%rsp), %xmm0
xorl %edx, %edx
callq 0x105e0
testb $0x1, %al
jne 0x25306
jmp 0x25317
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x4300
jmp 0x2539b
jmp 0x25308
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x252bb
movq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2533f
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2533d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x25394
callq 0x24f90
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movl $0x40, %edx
callq 0x4260
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x25396
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4520
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: CalcBrushBounds(brush_s const*, double (&) [3], double (&) [3])
void CalcBrushBounds (const brush_t *b, vec3_t &mins, vec3_t &maxs)
{
	VectorFill (mins, BOGUS_RANGE);
	VectorFill (maxs, -BOGUS_RANGE);
	for (side_t *s = b->sides; s; s = s->next)
	{
		vec3_t windingmins, windingmaxs;
		s->w->getBounds (windingmins, windingmaxs);
		VectorCompareMinimum (mins, windingmins, mins);
		VectorCompareMaximum (maxs, windingmaxs, maxs);
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movsd 0x13cc2(%rip), %xmm0    # 0x39608
movsd %xmm0, (%rax)
movq 0x78(%rsp), %rax
movsd 0x13cb1(%rip), %xmm0    # 0x39608
movsd %xmm0, 0x8(%rax)
movq 0x78(%rsp), %rax
movsd 0x13c9f(%rip), %xmm0    # 0x39608
movsd %xmm0, 0x10(%rax)
movq 0x70(%rsp), %rax
movsd 0x14c95(%rip), %xmm0    # 0x3a610
movsd %xmm0, (%rax)
movq 0x70(%rsp), %rax
movsd 0x14c84(%rip), %xmm0    # 0x3a610
movsd %xmm0, 0x8(%rax)
movq 0x70(%rsp), %rax
movsd 0x14c72(%rip), %xmm0    # 0x3a610
movsd %xmm0, 0x10(%rax)
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x25b6d
movq 0x68(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xdec0
movq 0x78(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x50(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x259fe
movq 0x78(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x25a0a
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x78(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x78(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x25a41
movq 0x78(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x25a4d
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movq 0x78(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x78(%rsp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x60(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x25a85
movq 0x78(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x25a91
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x78(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x70(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x25ac3
movq 0x70(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x25acf
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x70(%rsp), %rax
movsd 0x8(%rax), %xmm0
ucomisd 0x38(%rsp), %xmm0
jbe 0x25b02
movq 0x70(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x25b0e
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x70(%rsp), %rax
movsd 0x10(%rax), %xmm0
ucomisd 0x40(%rsp), %xmm0
jbe 0x25b41
movq 0x70(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, (%rsp)
jmp 0x25b4c
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
jmp 0x259b4
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: AddPointToBounds(double const*, double*, double*)
void            AddPointToBounds(const vec3_t v, vec3_t mins, vec3_t maxs)
{
    int             i;
    vec_t           val;

    for (i = 0; i < 3; i++)
    {
        val = v[i];
        if (val < mins[i])
        {
            mins[i] = val;
        }
        if (val > maxs[i])
        {
            maxs[i] = val;
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x3, -0x1c(%rsp)
jge 0x25c55
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm1
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x25c17
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x28(%rsp), %xmm0
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x25c43
movsd -0x28(%rsp), %xmm0
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x25c45
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x25bc7
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: CheckFaceForDiscardable(face_s const*)
bool CheckFaceForDiscardable (const face_t *f)
{
	const char *name = GetTextureByNumber (f->texturenum);
	if (!strncasecmp (name, "SOLIDHINT", 9))
		return true;
	return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x6950
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x1497d(%rip), %rsi     # 0x3a792
movl $0x9, %edx
callq 0x43c0
cmpl $0x0, %eax
jne 0x25e2b
movb $0x1, 0x17(%rsp)
jmp 0x25e30
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/qbsp.cpp
// Function: SetFaceType(face_s*)
static          facestyle_e SetFaceType(face_t* f)
{
    if (CheckFaceForHint(f))
    {
        f->facestyle = face_hint;
    }
    else if (CheckFaceForSkip(f))
    {
        f->facestyle = face_skip;
    }
#ifdef ZHLT_NULLTEX         // AJM
    else if (CheckFaceForNull(f))
    {
        f->facestyle = face_null;
    }
#endif
#ifdef HLCSG_HLBSP_SOLIDHINT
	else if (CheckFaceForDiscardable (f))
	{
		f->facestyle = face_discardable;
	}
#endif

// =====================================================================================
//Cpt_Andrew - Env_Sky Check
// =====================================================================================
   //else if (CheckFaceForUTSky(f))
	else if (CheckFaceForEnv_Sky(f))
    {
        f->facestyle = face_null;
    }
// =====================================================================================


#ifdef ZHLT_DETAIL
    else if (CheckFaceForDetail(f))
    {
        //Log("SetFaceType::detail face\n");
        f->facestyle = face_detail;
    }
#endif
    else
    {
        f->facestyle = face_normal;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x25d50
testb $0x1, %al
jne 0x293c4
jmp 0x293d4
movq (%rsp), %rax
movl $0x1, 0x30(%rax)
jmp 0x29457
movq (%rsp), %rdi
callq 0x25da0
testb $0x1, %al
jne 0x293e3
jmp 0x293f0
movq (%rsp), %rax
movl $0x2, 0x30(%rax)
jmp 0x29455
movq (%rsp), %rdi
callq 0x25c60
testb $0x1, %al
jne 0x293ff
jmp 0x2940c
movq (%rsp), %rax
movl $0x3, 0x30(%rax)
jmp 0x29453
movq (%rsp), %rdi
callq 0x25df0
testb $0x1, %al
jne 0x2941b
jmp 0x29428
movq (%rsp), %rax
movl $0x4, 0x30(%rax)
jmp 0x29451
movq (%rsp), %rdi
callq 0x25d00
testb $0x1, %al
jne 0x29437
jmp 0x29444
movq (%rsp), %rax
movl $0x3, 0x30(%rax)
jmp 0x2944f
movq (%rsp), %rax
movl $0x0, 0x30(%rax)
jmp 0x29451
jmp 0x29453
jmp 0x29455
jmp 0x29457
movq (%rsp), %rax
movl 0x30(%rax), %eax
popq %rcx
retq
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: BuildSurfaceTree(surface_s*, double)
surfacetree_t *BuildSurfaceTree (surface_t *surfaces, vec_t epsilon)
{
	surfacetree_t *tree;
	tree = (surfacetree_t *)malloc (sizeof (surfacetree_t));
	tree->epsilon = epsilon;
	tree->result.middle = new std::vector< face_t * >;
	tree->headnode = (surfacetreenode_t *)malloc (sizeof (surfacetreenode_t));
	tree->headnode->leaffaces = new std::vector< face_t * >;
	{
		surface_t *p2;
		face_t *f;
		for (p2 = surfaces; p2; p2 = p2->next)
		{
			if (p2->onnode)
			{
				continue;
			}
			for (f = p2->faces; f; f = f->next)
			{
				tree->headnode->leaffaces->push_back (f);
			}
		}
	}
	tree->dontbuild = tree->headnode->leaffaces->size () < 20;
	BuildSurfaceTree_r (tree, tree->headnode);
	if (tree->dontbuild)
	{
		*tree->result.middle = *tree->headnode->leaffaces;
		tree->result.backsize = 0;
		tree->result.frontsize = 0;
	}
	return tree;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movl $0x28, %edi
callq 0x43e0
movq %rax, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x2e4d0
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x68, %edi
callq 0x43e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x2e4d0
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x60(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2a5dd
movq 0x18(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2a590
jmp 0x2a5ce
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2a5cc
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e4e0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2a59e
jmp 0x2a5ce
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2a57a
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rdi
callq 0x2e3e0
cmpq $0x14, %rax
setb %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x29800
movq 0x20(%rsp), %rax
testb $0x1, (%rax)
je 0x2a650
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2e5b0
movq 0x20(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: TestSurfaceTree(surfacetree_t*, plane_t const*)
void TestSurfaceTree (surfacetree_t *tree, const dplane_t *split)
{
	if (tree->dontbuild)
	{
		return;
	}
	tree->result.middle->clear ();
	tree->result.backsize = 0;
	tree->result.frontsize = 0;
	TestSurfaceTree_r (tree, tree->headnode, split);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x2a98a
jmp 0x2a9c8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2e870
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x2a660
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: DeleteSurfaceTree_r(surfacetreenode_s*)
void DeleteSurfaceTree_r (surfacetreenode_t *node)
{
	if (node->isleaf)
	{
		delete node->leaffaces;
	}
	else
	{
		DeleteSurfaceTree_r (node->children[0]);
		free (node->children[0]);
		DeleteSurfaceTree_r (node->children[1]);
		free (node->children[1]);
		delete node->nodefaces;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x38(%rax)
je 0x2aa13
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2aa11
movq 0x8(%rsp), %rdi
callq 0x2e550
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x4300
jmp 0x2aa77
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x2a9d0
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x4370
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x2a9d0
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x4370
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2aa75
movq (%rsp), %rdi
callq 0x2e550
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x4300
jmp 0x2aa77
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: DeleteSurfaceTree(surfacetree_t*)
void DeleteSurfaceTree (surfacetree_t *tree)
{
	DeleteSurfaceTree_r (tree->headnode);
	free (tree->headnode);
	delete tree->result.middle;
	free (tree);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2a9d0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x4370
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2aad2
movq 0x8(%rsp), %rdi
callq 0x2e550
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x4300
movq 0x10(%rsp), %rdi
callq 0x4370
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: CalcSplitDetaillevel(node_s const*)
int CalcSplitDetaillevel (const node_t *node)
{
	int bestdetaillevel = -1;
	surface_t *s;
	face_t *f;
	for (s = node->surfaces; s; s = s->next)
	{
		if (s->onnode)
		{
			continue;
		}
#ifdef HLCSG_HLBSP_SOLIDHINT
		for (f = s->faces; f; f = f->next)
		{
			if (f->facestyle == face_discardable)
			{
				continue;
			}
			if (bestdetaillevel == -1 || f->detaillevel < bestdetaillevel)
			{
				bestdetaillevel = f->detaillevel;
			}
		}
#else
		if (bestdetaillevel == -1 || s->detaillevel < bestdetaillevel)
		{
			bestdetaillevel = s->detaillevel;
		}
#endif
	}
	return bestdetaillevel;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0xffffffff, -0xc(%rsp) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x2ab86
movq -0x18(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2ab20
jmp 0x2ab77
movq -0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x2ab75
movq -0x20(%rsp), %rax
cmpl $0x4, 0x30(%rax)
jne 0x2ab43
jmp 0x2ab66
cmpl $-0x1, -0xc(%rsp)
je 0x2ab58
movq -0x20(%rsp), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rsp), %eax
jge 0x2ab64
movq -0x20(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, -0xc(%rsp)
jmp 0x2ab66
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2ab2e
jmp 0x2ab77
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x2ab0a
movl -0xc(%rsp), %eax
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: FixDetaillevelForDiscardable(node_s*, int)
void FixDetaillevelForDiscardable (node_t *node, int detaillevel)
{
	// when we move on to the next detaillevel, some discardable faces of previous detail level remain not on node (because they are discardable). remove them now
	surface_t *s, **psnext;
	face_t *f, **pfnext;
	for (psnext = &node->surfaces; s = *psnext, s != NULL; )
	{
		if (s->onnode)
		{
			psnext = &s->next;
			continue;
		}
		hlassume (s->faces, assume_ValidPointer);
		for (pfnext = &s->faces; f = *pfnext, f != NULL; )
		{
			if (detaillevel == -1 || f->detaillevel < detaillevel)
			{
				*pfnext = f->next;
				FreeFace (f);
			}
			else
			{
				pfnext = &f->next;
			}
		}
		if (!s->faces)
		{
			*psnext = s->next;
			FreeSurface (s);
		}
		else
		{
			psnext = &s->next;
			CalcSurfaceInfo (s);
			hlassume (!(detaillevel == -1 || s->detaillevel < detaillevel), assume_first);
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2acc9
movq 0x20(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2abd8
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2aba7
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x2, %esi
callq 0xbe90
movq 0x20(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2ac55
cmpl $-0x1, 0x2c(%rsp)
je 0x2ac2d
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2ac49
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x24f00
jmp 0x2ac53
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ac03
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2ac7d
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x24f40
jmp 0x2acc4
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2acd0
movb $0x1, %al
cmpl $-0x1, 0x2c(%rsp)
movb %al, 0x7(%rsp)
je 0x2acb1
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
cmpl 0x2c(%rsp), %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
xorl %esi, %esi
callq 0xbe90
jmp 0x2aba7
addq $0x38, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: ContentsToString(int)
const char*     ContentsToString(int contents)
{
    switch (contents)
    {
    case CONTENTS_EMPTY:
        return "EMPTY";
    case CONTENTS_SOLID:
        return "SOLID";
    case CONTENTS_WATER:
        return "WATER";
    case CONTENTS_SLIME:
        return "SLIME";
    case CONTENTS_LAVA:
        return "LAVA";
    case CONTENTS_SKY:
        return "SKY";
    case CONTENTS_CURRENT_0:
        return "CURRENT_0";
    case CONTENTS_CURRENT_90:
        return "CURRENT_90";
    case CONTENTS_CURRENT_180:
        return "CURRENT_180";
    case CONTENTS_CURRENT_270:
        return "CURRENT_270";
    case CONTENTS_CURRENT_UP:
        return "CURRENT_UP";
    case CONTENTS_CURRENT_DOWN:
        return "CURRENT_DOWN";
    case CONTENTS_TRANSLUCENT:
        return "TRANSLUCENT";
    default:
        return "UNKNOWN";
    }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0xf, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0xe, %eax
ja 0x2afc2
movq -0x18(%rsp), %rax
leaq 0x10a29(%rip), %rcx     # 0x3b920
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10b10(%rip), %rax     # 0x3ba17
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10b05(%rip), %rax     # 0x3ba1d
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10afa(%rip), %rax     # 0x3ba23
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10aef(%rip), %rax     # 0x3ba29
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ae4(%rip), %rax     # 0x3ba2f
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10adb(%rip), %rax     # 0x3ba34
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ad1(%rip), %rax     # 0x3ba38
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10acd(%rip), %rax     # 0x3ba42
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10aca(%rip), %rax     # 0x3ba4d
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ac8(%rip), %rax     # 0x3ba59
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ac6(%rip), %rax     # 0x3ba65
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ac3(%rip), %rax     # 0x3ba70
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ac2(%rip), %rax     # 0x3ba7d
movq %rax, -0x8(%rsp)
jmp 0x2afce
leaq 0x10ac0(%rip), %rax     # 0x3ba89
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: CopyFacesToNode(node_s*, surface_s*)
static void     CopyFacesToNode(node_t* node, surface_t* surf)
{
    face_t**        prevptr;
    face_t*         f;
    face_t*         newf;

    // merge as much as possible
    MergePlaneFaces(surf);

    // subdivide large faces
    prevptr = &surf->faces;
    while (1)
    {
        f = *prevptr;
        if (!f)
        {
            break;
        }
        SubdivideFace(f, prevptr);
        f = *prevptr;
        prevptr = &f->next;
    }

    // copy the faces to the node, and consider them the originals
    node->surfaces = NULL;
    node->faces = NULL;
    for (f = surf->faces; f; f = f->next)
    {
#ifdef HLCSG_HLBSP_SOLIDHINT
		if (f->facestyle == face_discardable)
		{
			continue;
		}
#endif
        if (f->contents != CONTENTS_SOLID)
        {
            newf = AllocFace();
            *newf = *f;
            f->original = newf;
            newf->next = node->faces;
            node->faces = newf;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x207d0
movq 0x18(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2c45d
jmp 0x2c485
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2fa50
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2c446
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c52c
movq 0x8(%rsp), %rax
cmpl $0x4, 0x30(%rax)
jne 0x2c4c4
jmp 0x2c51d
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x10(%rax)
je 0x2c51b
callq 0x23df0
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movl $0x4b8, %edx            # imm = 0x4B8
callq 0x4260
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x98(%rax)
jmp 0x2c51d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c4af
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/solidbsp.cpp
// Function: SplitNodeSurfaces(surface_s*, node_s const*)
static void     SplitNodeSurfaces(surface_t* surfaces, const node_t* const node)
{
    surface_t*      p;
    surface_t*      next;
    surface_t*      frontlist;
    surface_t*      backlist;
    surface_t*      frontfrag;
    surface_t*      backfrag;
    dplane_t*       splitplane;

    splitplane = &g_dplanes[node->planenum];

    frontlist = NULL;
    backlist = NULL;
	
    for (p = surfaces; p; p = next)
    {
        next = p->next;
        DivideSurface(p, splitplane, &frontfrag, &backfrag);

        if (frontfrag)
        {
            if (!frontfrag->faces)
            {
                Error("surface with no faces");
            }
            frontfrag->next = frontlist;
            frontlist = frontfrag;
        }
        if (backfrag)
        {
            if (!backfrag->faces)
            {
                Error("surface with no faces");
            }
            backfrag->next = backlist;
            backlist = backfrag;
        }
    }

    node->children[0]->surfaces = frontlist;
    node->children[1]->surfaces = backlist;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movslq 0x80(%rax), %rcx
leaq 0x20c34cf(%rip), %rax   # 0x20efa30
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2c63c
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x2e0b0
cmpq $0x0, 0x10(%rsp)
je 0x2c5f2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2c5db
leaq 0xf696(%rip), %rdi      # 0x3bc6a
movb $0x0, %al
callq 0xb510
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c62b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2c614
leaq 0xf65d(%rip), %rdi      # 0x3bc6a
movb $0x0, %al
callq 0xb510
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2c62d
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2c588
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x88(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)