LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::addPoint(double const*)
void            Winding::addPoint(const vec3_t newpoint)
{
    if (m_NumPoints >= m_MaxPoints)
    {
        resize(m_NumPoints + 1);
    }
    VectorCopy(newpoint, m_Points[m_NumPoints]);
    m_NumPoints++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x8(%rcx), %eax
cmpl 0x18(%rcx), %eax
jb 0x11e8e
movq (%rsp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x11f00
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x8(%rax), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x8(%rax), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x8(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x8(%rax), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, 0x10(%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::resize(unsigned int)
void            Winding::resize(UINT32 newsize)
{
    newsize = (newsize + 3) & ~3;   // groups of 4

    vec3_t* newpoints = new vec3_t[newsize];
    m_NumPoints = qmin(newsize, m_NumPoints);
    memcpy(newpoints, m_Points, m_NumPoints);
    delete[] m_Points;
    m_Points = newpoints;
    m_MaxPoints = newsize;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq 0x18(%rsp), %rcx
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x11f67
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x11f73
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rax), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x4310
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x11fb0
movq 0x8(%rsp), %rdi
callq 0x44f0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::insertPoint(double const*, unsigned int)
void            Winding::insertPoint(const vec3_t newpoint, const unsigned int offset)
{
    if (offset >= m_NumPoints)
    {
        addPoint(newpoint);
    }
    else
    {
        if (m_NumPoints >= m_MaxPoints)
        {
            resize(m_NumPoints + 1);
        }

        unsigned x;
        for (x = m_NumPoints; x>offset; x--)
        {
            VectorCopy(m_Points[x-1], m_Points[x]);
        }
        VectorCopy(newpoint, m_Points[x]);

        m_NumPoints++;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jb 0x12009
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11e60
jmp 0x12140
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %eax
cmpl 0x18(%rcx), %eax
jb 0x12026
movq 0x8(%rsp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x11f00
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jbe 0x120da
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rax
movl 0x10(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x12032
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x18(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl 0x10(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd %xmm0, 0x10(%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::CopyPoints(double (*) [3], int&)
void			Winding::CopyPoints(vec3_t *points, int &numpoints)
{
	if(!points)
	{
		numpoints = 0;
		return;
	}

	memcpy(points, m_Points, sizeof(vec3_t) * m_NumPoints);

	numpoints = m_NumPoints;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x12182
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
jmp 0x121ab
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
callq 0x4310
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/common/mathlib.h
// Function: VectorNormalize(double*)
inline vec_t   VectorNormalize(vec3_t v)
{
    double          length;

    length = DotProduct(v, v);
    length = sqrt(length);
    if (length < NORMAL_EPSILON)
    {
        VectorClear(v);
        return 0.0;
    }

    v[0] /= length;
    v[1] /= length;
    v[2] /= length;

    return length;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm2
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x8(%rsp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x42f0
movsd %xmm0, (%rsp)
movsd 0x17e49(%rip), %xmm0    # 0x2a068
ucomisd (%rsp), %xmm0
jbe 0x12257
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x122a8
movsd (%rsp), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd (%rsp), %xmm1
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd (%rsp), %xmm1
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: FreeSlave[P]vhlt/common/boundingbox.h
// Function: BoundingBox::add(double const*)
void add(const vec3_t point)
    {
        m_Mins[0] = qmin(m_Mins[0], point[0]);
        m_Maxs[0] = qmax(m_Maxs[0], point[0]);
        m_Mins[1] = qmin(m_Mins[1], point[1]);
        m_Maxs[1] = qmax(m_Maxs[1], point[1]);
        m_Mins[2] = qmin(m_Mins[2], point[2]);
        m_Maxs[2] = qmax(m_Maxs[2], point[2]);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movsd (%rax), %xmm1
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12308
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x12317
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x18(%rsp), %rax
movsd -0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rax), %xmm0
movq -0x10(%rsp), %rax
ucomisd (%rax), %xmm0
jbe 0x12348
movq -0x18(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x12357
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
movq -0x18(%rsp), %rax
movsd -0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x8(%rax), %xmm1
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1238e
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rsp)
jmp 0x1239e
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rsp)
movq -0x18(%rsp), %rax
movsd -0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x20(%rax), %xmm0
movq -0x10(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x123d1
movq -0x18(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x123e1
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rsp)
movq -0x18(%rsp), %rax
movsd -0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x10(%rax), %xmm1
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12418
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x40(%rsp)
jmp 0x12428
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x40(%rsp)
movq -0x18(%rsp), %rax
movsd -0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x28(%rax), %xmm0
movq -0x10(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x1245b
movq -0x18(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x1246b
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rsp)
movq -0x18(%rsp), %rax
movsd -0x48(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: PlaneFromPoints(double const*, double const*, double const*)
int PlaneFromPoints(const vec_t* const p0, const vec_t* const p1, const vec_t* const p2)
{
    vec3_t          v1, v2;
    vec3_t          normal;

    VectorSubtract(p0, p1, v1);
    VectorSubtract(p2, p1, v2);
    CrossProduct(v1, v2, normal);
    if (VectorNormalize(normal))
    {
        return FindIntPlane(normal, p0);
    }
    return -1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movsd (%rax), %xmm0
movq 0x60(%rsp), %rax
subsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x68(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x60(%rsp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x68(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x60(%rsp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x58(%rsp), %rax
movsd (%rax), %xmm0
movq 0x60(%rsp), %rax
subsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x60(%rsp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x60(%rsp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x50(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x121b0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x12ba6
jp 0x12ba6
jmp 0x12bb9
movq %rsp, %rdi
movq 0x68(%rsp), %rsi
callq 0x124f0
movl %eax, 0x74(%rsp)
jmp 0x12bc1
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: AddHullPlane(brushhull_t*, double const*, double const*, bool)
void AddHullPlane(brushhull_t* hull, const vec_t* const normal, const vec_t* const origin, const bool check_planenum)
{
	int planenum = FindIntPlane(normal,origin);
	//check to see if this plane is already in the brush (optional to speed
	//up cases where we know the plane hasn't been added yet, like axial case)
	if(check_planenum)
	{
#ifndef HLCSG_HULLBRUSH
		if(g_mapplanes[planenum].type <= last_axial) //we know axial planes are added in last step
		{ return; }
#endif

		bface_t* current_face;
		for(current_face = hull->faces; current_face; current_face = current_face->next)
		{
			if(current_face->planenum == planenum)
			{ return; } //don't add a plane twice
		}
	}
	bface_t* new_face = (bface_t*)Alloc(sizeof(bface_t)); // TODO: This leaks
	new_face->planenum = planenum;
	new_face->plane = &g_mapplanes[new_face->planenum];
	new_face->next = hull->faces;
	new_face->contents = CONTENTS_EMPTY;
	hull->faces = new_face;
#ifdef HLCSG_HLBSP_VOIDTEXINFO
	new_face->texinfo = -1;
#else
	new_face->texinfo = 0;
#endif
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x124f0
movl %eax, 0x18(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x12c61
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12c5f
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x18(%rsp), %eax
jne 0x12c4e
jmp 0x12cd3
jmp 0x12c50
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x12c33
jmp 0x12c61
movl $0x68, %edi
callq 0x4aa0
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
leaq 0x20c7d14(%rip), %rcx   # 0x20da9a0
shlq $0x6, %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: ContentsToString(contents_t)
const char*     ContentsToString(const contents_t type)
{
    switch (type)
    {
    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_ORIGIN:
        return "ORIGIN";
#ifdef HLCSG_HLBSP_CUSTOMBOUNDINGBOX
	case CONTENTS_BOUNDINGBOX:
		return "BOUNDINGBOX";
#endif
#ifndef HLCSG_CUSTOMHULL
    case CONTENTS_CLIP:
        return "CLIP";
#endif
    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";
    case CONTENTS_HINT:
        return "HINT";

#ifdef ZHLT_NULLTEX // AJM
    case CONTENTS_NULL:
        return "NULL";
#endif

#ifdef ZHLT_DETAIL // AJM
    case CONTENTS_DETAIL:
        return "DETAIL";
#endif

#ifdef HLCSG_EMPTYBRUSH
	case CONTENTS_TOEMPTY:
		return "EMPTY";
#endif

    default:
        return "UNKNOWN";
    }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0x20, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x1f, %eax
ja 0x16387
movq -0x18(%rsp), %rax
leaq 0x17449(%rip), %rcx     # 0x2d6b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x17699(%rip), %rax     # 0x2d910
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x1768e(%rip), %rax     # 0x2d916
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17683(%rip), %rax     # 0x2d91c
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17678(%rip), %rax     # 0x2d922
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x1766d(%rip), %rax     # 0x2d928
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17661(%rip), %rax     # 0x2d92d
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17654(%rip), %rax     # 0x2d931
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x1764a(%rip), %rax     # 0x2d938
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17645(%rip), %rax     # 0x2d944
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x1763e(%rip), %rax     # 0x2d94e
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x1763b(%rip), %rax     # 0x2d959
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17639(%rip), %rax     # 0x2d965
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17637(%rip), %rax     # 0x2d971
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17634(%rip), %rax     # 0x2d97c
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17633(%rip), %rax     # 0x2d989
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x18130(%rip), %rax     # 0x2e494
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17a47(%rip), %rax     # 0x2ddb9
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17590(%rip), %rax     # 0x2d910
movq %rax, -0x8(%rsp)
jmp 0x16393
leaq 0x17607(%rip), %rax     # 0x2d995
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: CreateBrush(int)
void CreateBrush(const int brushnum) //--vluzacn
{
	brush_t*        b;
	int             contents;
	int             h;

	b = &g_mapbrushes[brushnum];

	contents = b->contents;

	if (contents == CONTENTS_ORIGIN)
		return;
#ifdef HLCSG_HLBSP_CUSTOMBOUNDINGBOX
	if (contents == CONTENTS_BOUNDINGBOX)
		return;
#endif

	//  HULL 0
	MakeBrushPlanes(b);
	MakeHullFaces(b, &b->hulls[0]);

	if (contents == CONTENTS_HINT)
		return;
#ifdef HLCSG_EMPTYBRUSH
	if (contents == CONTENTS_TOEMPTY)
		return;
#endif

	if (g_noclip)
	{
		if (b->cliphull)
		{
			b->hulls[0].faces = NULL;
		}
		return;
	}

	if (b->cliphull)
	{
		for (h = 1; h < NUM_HULLS; h++)
		{
			if (b->cliphull & (1 << h))
			{
				ExpandBrush(b, h);
				MakeHullFaces(b, &b->hulls[h]);
			}
		}
        b->contents = CONTENTS_SOLID;
		b->hulls[0].faces = NULL;
	}
	else
	{
		if (b->noclip)
			return;
		for (h = 1; h < NUM_HULLS; h++)
		{
			ExpandBrush(b, h);
			MakeHullFaces(b, &b->hulls[h]);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x30c4a4c(%rip), %rax   # 0x30db640
imulq $0x140, %rcx, %rcx      # imm = 0x140
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $-0x7, 0x4(%rsp)
jne 0x16c1b
jmp 0x16d63
cmpl $-0x13, 0x4(%rsp)
jne 0x16c27
jmp 0x16d63
movq 0x8(%rsp), %rdi
callq 0x15ef0
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x60, %rsi
callq 0x15bf0
cmpl $-0x10, 0x4(%rsp)
jne 0x16c50
jmp 0x16d63
cmpl $-0x20, 0x4(%rsp)
jne 0x16c5c
jmp 0x16d63
leaq 0x61c4a65(%rip), %rax   # 0x61db6c8
testb $0x1, (%rax)
je 0x16c88
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x16c83
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
jmp 0x16d63
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x16d11
movl $0x1, (%rsp)
cmpl $0x4, (%rsp)
jge 0x16cf3
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movl (%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x16ce6
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0x14130
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x60, %rsi
movslq (%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
callq 0x15bf0
jmp 0x16ce8
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x16c9a
movq 0x8(%rsp), %rax
movl $0xfffffffe, 0x58(%rax) # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
jmp 0x16d63
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x16d1e
jmp 0x16d63
movl $0x1, (%rsp)
cmpl $0x4, (%rsp)
jge 0x16d61
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0x14130
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x60, %rsi
movslq (%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
callq 0x15bf0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x16d25
jmp 0x16d63
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: DeleteHullBrush(hullbrush_t*)
void DeleteHullBrush (hullbrush_t *hb)
{
	for (hullbrushface_t *hbf = hb->faces; hbf < hb->faces + hb->numfaces; hbf++)
	{
		if (hbf->vertexes)
		{
			free (hbf->vertexes);
		}
	}
	free (hb->faces);
	free (hb->edges);
	free (hb->vertexes);
	free (hb);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rsp), %rdx
movslq (%rdx), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x18975
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x18963
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x4470
jmp 0x18965
movq 0x8(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
jmp 0x18927
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4470
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x4470
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x4470
movq 0x10(%rsp), %rdi
callq 0x4470
addq $0x18, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: InitDefaultHulls()
void InitDefaultHulls ()
{
	for (int h = 0; h < NUM_HULLS; h++)
	{
		hullshape_t *hs = &g_defaulthulls[h];
		hs->id = _strdup ("");
		hs->disabled = true;
		hs->numbrushes = 0;
		hs->brushes = (hullbrush_t **)malloc (0 * sizeof (hullbrush_t *));
		hlassume (hs->brushes != NULL, assume_NoMemory);
	}
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x18a4d
movslq 0x14(%rsp), %rcx
leaq 0x30c1fdd(%rip), %rax   # 0x30da9b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x13353(%rip), %rdi     # 0x2bd39
callq 0x46b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x4500
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xc400
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x189bc
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/mathlib.h
// Function: PlaneTypeForNormal(double*)
inline planetypes PlaneTypeForNormal(vec3_t normal)
{
    vec_t           ax, ay, az;

    ax = fabs(normal[0]);
    ay = fabs(normal[1]);
    az = fabs(normal[2]);
#ifdef HLCSG_FACENORMALEPSILON
    if (ax > 1.0 - DIR_EPSILON && ay < DIR_EPSILON && az < DIR_EPSILON)
    {
        return plane_x;
    }

    if (ay > 1.0 - DIR_EPSILON && az < DIR_EPSILON && ax < DIR_EPSILON)
    {
        return plane_y;
    }

    if (az > 1.0 - DIR_EPSILON && ax < DIR_EPSILON && ay < DIR_EPSILON)
    {
        return plane_z;
    }
#else
    if (ax > 1.0 - NORMAL_EPSILON && ay < NORMAL_EPSILON && az < NORMAL_EPSILON)
    {
        return plane_x;
    }

    if (ay > 1.0 - NORMAL_EPSILON && az < NORMAL_EPSILON && ax < NORMAL_EPSILON)
    {
        return plane_y;
    }

    if (az > 1.0 - NORMAL_EPSILON && ax < NORMAL_EPSILON && ay < NORMAL_EPSILON)
    {
        return plane_z;
    }
#endif

    if ((ax >= ay) && (ax >= az))
    {
        return plane_anyx;
    }
    if ((ay >= ax) && (ay >= az))
    {
        return plane_anyy;
    }
    return plane_anyz;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movaps 0x1470b(%rip), %xmm1    # 0x2d4b0
pand %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movaps 0x146f0(%rip), %xmm1    # 0x2d4b0
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movaps 0x146d5(%rip), %xmm1    # 0x2d4b0
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x18(%rsp), %xmm0
movsd 0x1486d(%rip), %xmm1    # 0x2d660
ucomisd %xmm1, %xmm0
jbe 0x18e26
movsd 0x14847(%rip), %xmm0    # 0x2d648
ucomisd -0x20(%rsp), %xmm0
jbe 0x18e26
movsd 0x14837(%rip), %xmm0    # 0x2d648
ucomisd -0x28(%rsp), %xmm0
jbe 0x18e26
movl $0x0, -0x4(%rsp)
jmp 0x18ef9
movsd -0x20(%rsp), %xmm0
movsd 0x1482c(%rip), %xmm1    # 0x2d660
ucomisd %xmm1, %xmm0
jbe 0x18e67
movsd 0x14806(%rip), %xmm0    # 0x2d648
ucomisd -0x28(%rsp), %xmm0
jbe 0x18e67
movsd 0x147f6(%rip), %xmm0    # 0x2d648
ucomisd -0x18(%rsp), %xmm0
jbe 0x18e67
movl $0x1, -0x4(%rsp)
jmp 0x18ef9
movsd -0x28(%rsp), %xmm0
movsd 0x147eb(%rip), %xmm1    # 0x2d660
ucomisd %xmm1, %xmm0
jbe 0x18ea5
movsd 0x147c5(%rip), %xmm0    # 0x2d648
ucomisd -0x18(%rsp), %xmm0
jbe 0x18ea5
movsd 0x147b5(%rip), %xmm0    # 0x2d648
ucomisd -0x20(%rsp), %xmm0
jbe 0x18ea5
movl $0x2, -0x4(%rsp)
jmp 0x18ef9
movsd -0x18(%rsp), %xmm0
ucomisd -0x20(%rsp), %xmm0
jb 0x18ecb
movsd -0x18(%rsp), %xmm0
ucomisd -0x28(%rsp), %xmm0
jb 0x18ecb
movl $0x3, -0x4(%rsp)
jmp 0x18ef9
movsd -0x20(%rsp), %xmm0
ucomisd -0x18(%rsp), %xmm0
jb 0x18ef1
movsd -0x20(%rsp), %xmm0
ucomisd -0x28(%rsp), %xmm0
jb 0x18ef1
movl $0x4, -0x4(%rsp)
jmp 0x18ef9
movl $0x5, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: FreeSlave[P]vhlt/common/mathlib.h
// Function: VectorCompare(double const*, double const*)
inline bool     VectorCompare(const vec3_t v1, const vec3_t v2)
{
    int             i;

    for (i = 0; i < 3; i++)
    {
        if (fabs(v1[i] - v2[i]) > EQUAL_EPSILON)
        {
            return false;
        }
    }
    return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x3, -0x1c(%rsp)
jge 0x18f66
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movaps 0x14572(%rip), %xmm1    # 0x2d4b0
pand %xmm1, %xmm0
movsd 0x14736(%rip), %xmm1    # 0x2d680
ucomisd %xmm1, %xmm0
jbe 0x18f57
movb $0x0, -0x1(%rsp)
jmp 0x18f6b
jmp 0x18f59
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x18f12
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/brushunion.cpp
// Function: DumpHullWindings(brushhull_t const*)
static void     DumpHullWindings(const brushhull_t* const hull)
{
    int             x = 0;
    bface_t*        face;

    for (face = hull->faces; face; face = face->next)
    {
        Developer(DEVELOPER_LEVEL_MEGASPAM, "Winding %d\n", x++);
        face->w->Print();
        Developer(DEVELOPER_LEVEL_MEGASPAM, "\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x196d2
movl 0xc(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x6, %edi
leaq 0x14720(%rip), %rsi     # 0x2ddbe
movb $0x0, %al
callq 0xc0f0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xdcf0
movl $0x6, %edi
leaq 0x1267a(%rip), %rsi     # 0x2bd38
movb $0x0, %al
callq 0xc0f0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x1967e
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brushunion.cpp
// Function: AddFaceToList(bface_s**, bface_s*)
static void     AddFaceToList(bface_t** head, bface_t* newface)
{
    hlassert(newface);
    hlassert(newface->w);
    if (!*head)
    {
        *head = newface;
        return;
    }
    else
    {
        bface_t*        node = *head;

        while (node->next)
        {
            node = node->next;
        }
        node->next = newface;
        newface->next = NULL;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x19cc4
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x19d04
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x19ceb
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x19cd1
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brushunion.cpp
// Function: NumberOfHullFaces(brushhull_t const*)
static int      NumberOfHullFaces(const brushhull_t* const hull)
{
    int             x;
    bface_t*        face;

    if (!hull->faces)
    {
        return 0;
    }

    for (x = 0, face = hull->faces; face; face = face->next, x++)
    {                                                  // counter
    }

    return x;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x19d2b
movl $0x0, -0x4(%rsp)
jmp 0x19d6d
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x19d65
jmp 0x19d4b
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x19d41
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/brushunion.cpp
// Function: NewWindingFromPlane(brushhull_t const*, int)
static Winding* NewWindingFromPlane(const brushhull_t* const hull, const int planenum)
{
    Winding*        winding;
    Winding*        front;
    Winding*        back;
    bface_t*        face;
    plane_t*        plane;

    plane = &g_mapplanes[planenum];
    winding = new Winding(plane->normal, plane->dist);

    for (face = hull->faces; face; face = face->next)
    {
        plane = &g_mapplanes[face->planenum];
        winding->Clip(plane->normal, plane->dist, &front, &back);
        delete winding;

        if (front)
        {
            delete front;
        }
        if (back)
        {
            winding = back;
        }
        else
        {
            Developer(DEVELOPER_LEVEL_ERROR, "NewFaceFromPlane returning NULL");
            return NULL;
        }
    }

    return winding;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movslq 0x54(%rsp), %rcx
shlq $0x6, %rcx
leaq 0x20c0c03(%rip), %rax   # 0x20da9a0
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl $0x20, %edi
callq 0x43b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
movsd 0x30(%rsi), %xmm0
callq 0xf770
jmp 0x19dcb
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x19ed9
movq 0x30(%rsp), %rax
movslq 0x8(%rax), %rcx
leaq 0x20c0ba1(%rip), %rax   # 0x20da9a0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rax
movsd 0x30(%rax), %xmm0
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
movsd 0x13827(%rip), %xmm1    # 0x2d658
callq 0xfe00
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x19e51
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x40(%rsp)
je 0x19e93
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x19e72
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x19e93
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x43c0
jmp 0x19eed
cmpq $0x0, 0x38(%rsp)
je 0x19ea7
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x19ec5
movl $0x1, %edi
leaq 0x13eeb(%rip), %rsi     # 0x2dd9e
movb $0x0, %al
callq 0xc0f0
movq $0x0, 0x60(%rsp)
jmp 0x19ee3
jmp 0x19ec7
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x19de3
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4650
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/map.cpp
// Function: TextureAxisFromPlane(plane_t const*, double*, double*)
void            TextureAxisFromPlane(const plane_t* const pln, vec3_t xv, vec3_t yv)
{
    int             bestaxis;
    vec_t           dot, best;
    int             i;

    best = 0;
    bestaxis = 0;

    for (i = 0; i < 6; i++)
    {
        dot = DotProduct(pln->normal, s_baseaxis[i * 3]);
        if (dot > best)
        {
            best = dot;
            bestaxis = i;
        }
    }

    VectorCopy(s_baseaxis[bestaxis * 3 + 1], xv);
    VectorCopy(s_baseaxis[bestaxis * 3 + 2], yv);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x34(%rsp)
cmpl $0x6, -0x34(%rsp)
jge 0x1a79a
movq -0x8(%rsp), %rax
movsd (%rax), %xmm1
imull $0x3, -0x34(%rsp), %eax
movslq %eax, %rcx
leaq 0x13e75(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm2
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
imull $0x3, -0x34(%rsp), %eax
movslq %eax, %rcx
leaq 0x13e51(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
imull $0x3, -0x34(%rsp), %eax
movslq %eax, %rcx
leaq 0x13e24(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
ucomisd -0x30(%rsp), %xmm0
jbe 0x1a788
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
movl -0x34(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x1a78a
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x1a6d8
imull $0x3, -0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x13dc4(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
imull $0x3, -0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x13d9e(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
imull $0x3, -0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x13d76(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
imull $0x3, -0x1c(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x13d4e(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
imull $0x3, -0x1c(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x13d28(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
imull $0x3, -0x1c(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x13d00(%rip), %rax     # 0x2e570
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, 0x10(%rax)
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/map.cpp
// Function: CountEngineEntities()
unsigned int    CountEngineEntities()
{
    unsigned int x;
    unsigned num_engine_entities = 0;
    entity_t*       mapent = g_entities;

    // for each entity in the map
    for (x=0; x<g_numentities; x++, mapent++)
    {
        const char* classname = ValueForKey(mapent, "classname");

        // if its a light_spot or light_env, dont include it as an engine entity!
        if (classname)
        {
            if (   !strncasecmp(classname, "light", 5) 
                || !strncasecmp(classname, "light_spot", 10) 
                || !strncasecmp(classname, "light_environment", 17)
               )
            {
                const char* style = ValueForKey(mapent, "style");
                const char* targetname = ValueForKey(mapent, "targetname");

                // lightspots and lightenviroments dont have a targetname or style
                if (!strlen(targetname) && !atoi(style))
                {
                    continue;
                }
            }
        }

        num_engine_entities++;
    }

    return num_engine_entities;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x20(%rsp)
leaq 0x200f6cd(%rip), %rax   # 0x202d4b0
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
leaq 0x200f6a9(%rip), %rcx   # 0x202d4a4
cmpl (%rcx), %eax
jae 0x1deee
movq 0x18(%rsp), %rdi
leaq 0xc747(%rip), %rsi      # 0x2a556
callq 0x7ff0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1dec5
movq 0x10(%rsp), %rdi
leaq 0xc7e9(%rip), %rsi      # 0x2a61a
movl $0x5, %edx
callq 0x44e0
cmpl $0x0, %eax
je 0x1de76
movq 0x10(%rsp), %rdi
leaq 0xc863(%rip), %rsi      # 0x2a6af
movl $0xa, %edx
callq 0x44e0
cmpl $0x0, %eax
je 0x1de76
movq 0x10(%rsp), %rdi
leaq 0xc799(%rip), %rsi      # 0x2a600
movl $0x11, %edx
callq 0x44e0
cmpl $0x0, %eax
jne 0x1dec3
movq 0x18(%rsp), %rdi
leaq 0x10f8f(%rip), %rsi     # 0x2ee11
callq 0x7ff0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xc80c(%rip), %rsi      # 0x2a6a4
callq 0x7ff0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x41c0
cmpq $0x0, %rax
jne 0x1dec1
movq 0x8(%rsp), %rdi
callq 0x45d0
cmpl $0x0, %eax
jne 0x1dec1
jmp 0x1ded0
jmp 0x1dec3
jmp 0x1dec5
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x18(%rsp)
jmp 0x1ddf0
movl 0x20(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/map.cpp
// Function: CheckForInvisible(entity_t*)
static bool CheckForInvisible(entity_t* mapent)
{
	using namespace std;

	string keyval(ValueForKey(mapent,"classname"));
	if(g_invisible_items.count(keyval))
	{ return true; }

	keyval.assign(ValueForKey(mapent,"targetname"));
	if(g_invisible_items.count(keyval))
	{ return true; }

	keyval.assign(ValueForKey(mapent,"zhlt_invisible"));
	if(!keyval.empty() && strcmp(keyval.c_str(),"0"))
	{ return true; }

	return false;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
leaq 0xc571(%rip), %rsi      # 0x2a556
callq 0x7ff0
movq %rax, 0x20(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4660
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x1e280
jmp 0x1e014
leaq 0x47(%rsp), %rdi
callq 0x43f0
leaq 0x61bd63b(%rip), %rdi   # 0x61db660
leaq 0x48(%rsp), %rsi
callq 0x1e340
movq %rax, 0x18(%rsp)
jmp 0x1e036
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x1e08d
movb $0x1, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x1e157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x43f0
jmp 0x1e16c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4240
jmp 0x1e16c
movq 0x68(%rsp), %rdi
leaq 0xc60b(%rip), %rsi      # 0x2a6a4
callq 0x7ff0
movq %rax, 0x10(%rsp)
jmp 0x1e0a5
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4720
jmp 0x1e0b6
leaq 0x61bd5a3(%rip), %rdi   # 0x61db660
leaq 0x48(%rsp), %rsi
callq 0x1e340
movq %rax, 0x8(%rsp)
jmp 0x1e0ce
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x1e0e8
movb $0x1, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x1e157
movq 0x68(%rsp), %rdi
leaq 0x10438(%rip), %rsi     # 0x2e52c
callq 0x7ff0
movq %rax, (%rsp)
jmp 0x1e0ff
movq (%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4720
jmp 0x1e10f
leaq 0x48(%rsp), %rdi
callq 0x4630
testb $0x1, %al
jne 0x1e14a
leaq 0x48(%rsp), %rdi
callq 0x41a0
movq %rax, %rdi
leaq 0xe51e(%rip), %rsi      # 0x2c64f
callq 0x4530
cmpl $0x0, %eax
je 0x1e14a
movb $0x1, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x1e157
movb $0x0, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4240
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4650
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: NewFaceFromFace(bface_s const*)
bface_t*        NewFaceFromFace(const bface_t* const in)
{
    bface_t*        newf;

    newf = (bface_t*)Alloc(sizeof(bface_t));

    newf->contents = in->contents;
    newf->texinfo = in->texinfo;
    newf->planenum = in->planenum;
    newf->plane = in->plane;
#ifdef HLCSG_EMPTYBRUSH
	newf->backcontents = in->backcontents;
#endif

    return newf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x68, %edi
callq 0x4aa0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: WriteDetailBrush(int, bface_s const*)
void WriteDetailBrush (int hull, const bface_t *faces)
{
	ThreadLock ();
	fprintf (out_detailbrush[hull], "0\n");
	for (const bface_t *f = faces; f; f = f->next)
	{
		Winding *w = f->w;
		fprintf (out_detailbrush[hull], "%i %u\n", f->planenum, w->m_NumPoints);
		for (int i = 0; i < w->m_NumPoints; i++)
		{
			fprintf (out_detailbrush[hull], "%5.8f %5.8f %5.8f\n", w->m_Points[i][0], w->m_Points[i][1], w->m_Points[i][2]);
		}
	}
	fprintf (out_detailbrush[hull], "-1 -1\n");
	ThreadUnlock ();
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
callq 0xd720
movslq 0x24(%rsp), %rcx
leaq 0x61bb552(%rip), %rax   # 0x61db750
movq (%rax,%rcx,8), %rdi
leaq 0xe7b9(%rip), %rsi      # 0x2e9c2
movb $0x0, %al
callq 0x4550
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x20307
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x61bb510(%rip), %rax   # 0x61db750
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
leaq 0xe73a(%rip), %rsi      # 0x2e995
movb $0x0, %al
callq 0x4550
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x202f3
movslq 0x24(%rsp), %rcx
leaq 0x61bb4cc(%rip), %rax   # 0x61db750
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm2
leaq 0xe6c0(%rip), %rsi      # 0x2e99c
movb $0x3, %al
callq 0x4550
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2026a
jmp 0x202f5
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2021a
movslq 0x24(%rsp), %rcx
leaq 0x61bb43d(%rip), %rax   # 0x61db750
movq (%rax,%rcx,8), %rdi
leaq 0xf8c9(%rip), %rsi      # 0x2fbe7
movb $0x0, %al
callq 0x4550
callq 0xd740
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: CopyFace(bface_s const*)
bface_t*        CopyFace(const bface_t* const f)
{
    bface_t*        n;

    n = NewFaceFromFace(f);
    n->w = f->w->Copy();
    n->bounds = f->bounds;
    return n;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1fdb0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xe760
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movl $0x30, %edx
callq 0x4310
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: CopyFaceList(bface_s*)
bface_t*        CopyFaceList(bface_t* f)
{
    bface_t*        head;
    bface_t*        n;

    if (f)
    {
        head = CopyFace(f);
        n = head;
        f = f->next;

        while (f)
        {
            n->next = CopyFace(f);

            n = n->next;
            f = f->next;
        }

        return head;
    }
    else
    {
        return NULL;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2040c
movq 0x18(%rsp), %rdi
callq 0x20330
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x20400
movq 0x18(%rsp), %rdi
callq 0x20330
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x203c7
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x20415
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: FreeFaceList(bface_s*)
void            FreeFaceList(bface_t* f)
{
    if (f)
    {
        if (f->next)
        {
            FreeFaceList(f->next);
        }
        FreeFace(f);
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2044b
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x20442
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x20420
movq (%rsp), %rdi
callq 0x1fe30
popq %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: LoadWadValue()
void LoadWadValue ()
{
	char *wadvalue;
	ParseFromMemory (g_dentdata, g_entdatasize);
	epair_t *e;
	entity_t ent0;
	entity_t *mapent = &ent0;
	memset (mapent, 0, sizeof (entity_t));
	if (!GetToken (true))
	{
		wadvalue = strdup ("");
	}
	else
	{
		if (strcmp (g_token, "{"))
		{
			Error ("ParseEntity: { not found");
		}
		while (1)
		{
			if (!GetToken (true))
			{
				Error ("ParseEntity: EOF without closing brace");
			}
			if (!strcmp (g_token, "}"))
			{
				break;
			}
			e = ParseEpair ();
			e->next = mapent->epairs;
			mapent->epairs = e;
		}
		wadvalue = strdup (ValueForKey (mapent, "wad"));
		epair_t *next;
		for (e = mapent->epairs; e; e = next)
		{
			next = e->next;
			free (e->key);
			free (e->value);
			free (e);
		}
	}
	if (*wadvalue)
	{
		Log ("Wad files required to run the map: \"%s\"\n", wadvalue);
	}
	else
	{
		Log ("Wad files required to run the map: (None)\n");
	}
	SetKeyValue (&g_entities[0], "wad", wadvalue);
	free (wadvalue);
}

// Assembly:
subq $0x48, %rsp
leaq 0x81ee89(%rip), %rax    # 0x83f524
movl (%rax), %esi
leaq 0x81ee8c(%rip), %rdi    # 0x83f530
callq 0xcc40
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x4210
movl $0x1, %edi
callq 0xce10
testb $0x1, %al
jne 0x206e8
leaq 0xb660(%rip), %rdi      # 0x2bd39
callq 0x46b0
movq %rax, 0x40(%rsp)
jmp 0x207e4
leaq 0x20b0e11(%rip), %rdi   # 0x20d1500
leaq 0x9dfa(%rip), %rsi      # 0x2a4f0
callq 0x4530
cmpl $0x0, %eax
je 0x2070e
leaq 0x9deb(%rip), %rdi      # 0x2a4f2
movb $0x0, %al
callq 0xba80
jmp 0x20710
movl $0x1, %edi
callq 0xce10
testb $0x1, %al
jne 0x2072c
leaq 0x9e08(%rip), %rdi      # 0x2a52d
movb $0x0, %al
callq 0xba80
leaq 0x20b0dcd(%rip), %rdi   # 0x20d1500
leaq 0x9e1a(%rip), %rsi      # 0x2a554
callq 0x4530
cmpl $0x0, %eax
jne 0x20746
jmp 0x20771
callq 0x7bd0
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x20710
movq 0x8(%rsp), %rdi
leaq 0xe2ac(%rip), %rsi      # 0x2ea29
callq 0x7ff0
movq %rax, %rdi
callq 0x46b0
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x207e2
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4470
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x4470
movq 0x38(%rsp), %rdi
callq 0x4470
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x2079d
jmp 0x207e4
movq 0x40(%rsp), %rax
cmpb $0x0, (%rax)
je 0x20803
movq 0x40(%rsp), %rsi
leaq 0x9b86(%rip), %rdi      # 0x2a380
movb $0x0, %al
callq 0xb5d0
jmp 0x20811
leaq 0x9af8(%rip), %rdi      # 0x2a302
movb $0x0, %al
callq 0xb5d0
movq 0x40(%rsp), %rdx
leaq 0x200cc93(%rip), %rdi   # 0x202d4b0
leaq 0xe205(%rip), %rsi      # 0x2ea29
callq 0x8070
movq 0x40(%rsp), %rdi
callq 0x4470
addq $0x48, %rsp
retq
nopl (%rax,%rax)