LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: FreeTransfers()
static void     FreeTransfers()
{
    unsigned        x;
    patch_t*        patch = g_patches;

    for (x = 0; x < g_num_patches; x++, patch++)
    {
        if (patch->tData)
        {
            FreeBlock(patch->tData);
            patch->tData = NULL;
        }
#ifdef HLRAD_HULLU
        if (patch->tRGBData)
        {
            FreeBlock(patch->tRGBData);
            patch->tRGBData = NULL;
        }
#endif
        if (patch->tIndex)
        {
            FreeBlock(patch->tIndex);
            patch->tIndex = NULL;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq 0x53986e5(%rip), %rax   # 0x53eda00
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x54186d6(%rip), %eax   # 0x546da08
jae 0x553cf
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x5535f
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x47d0
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x55386
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x47d0
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x553ad
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x47d0
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
jmp 0x553af
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x138, %rax            # imm = 0x138
movq %rax, 0x8(%rsp)
jmp 0x55328
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: ExtendLightmapBuffer()
static void ExtendLightmapBuffer ()
{
	int maxsize;
	int i;
	int j;
	int ofs;
	dface_t *f;

	maxsize = 0;
	for (i = 0; i < g_numfaces; i++)
	{
		f = &g_dfaces[i];
		if (f->lightofs >= 0)
		{
			ofs = f->lightofs;
			for (j = 0; j < MAXLIGHTMAPS && f->styles[j] != 255; j++)
			{
				ofs += (MAX_SURFACE_EXTENT + 1) * (MAX_SURFACE_EXTENT + 1) * 3;
			}
			if (ofs > maxsize)
			{
				maxsize = ofs;
			}
		}
	}
	if (maxsize >= g_lightdatasize)
	{
		hlassume (maxsize <= g_max_map_lightdata, assume_MAX_MAP_LIGHTING);
		memset (&g_dlightdata[g_lightdatasize], 0, maxsize - g_lightdatasize);
		g_lightdatasize = maxsize;
#ifdef ZHLT_XASH
		hlassume (maxsize < g_max_map_dlitdata, assume_MAX_MAP_LIGHTING);
		memset (&g_ddlitdata[g_dlitdatasize], 0, maxsize - g_dlitdatasize);
		g_dlitdatasize = maxsize;
#endif
	}
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
leaq 0x1b91005(%rip), %rcx   # 0x1be6404
cmpl (%rcx), %eax
jge 0x554b0
movslq 0x20(%rsp), %rcx
leaq 0x1b90ffd(%rip), %rax   # 0x1be6410
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x5549e
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x4, 0x1c(%rsp)
movb %al, 0xf(%rsp)
jge 0x55466
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movzbl 0xc(%rax,%rcx), %eax
cmpl $0xff, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x55470
jmp 0x5548a
movl 0x18(%rsp), %eax
addl $0x363, %eax            # imm = 0x363
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5543e
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jle 0x5549c
movl 0x18(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x5549e
jmp 0x554a0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x553f4
movl 0x24(%rsp), %eax
leaq 0x830fd9(%rip), %rcx    # 0x886494
cmpl (%rcx), %eax
jl 0x5551a
movl 0x24(%rsp), %eax
leaq 0x27e7a(%rip), %rcx     # 0x7d344
cmpl (%rcx), %eax
setle %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x38, %esi
callq 0xbf00
leaq 0x830fb2(%rip), %rax    # 0x886498
movq (%rax), %rdi
leaq 0x830fa4(%rip), %rax    # 0x886494
movslq (%rax), %rax
addq %rax, %rdi
movl 0x24(%rsp), %eax
leaq 0x830f93(%rip), %rcx    # 0x886494
subl (%rcx), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x41b0
movl 0x24(%rsp), %ecx
leaq 0x830f7c(%rip), %rax    # 0x886494
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: getEmitMode(patch_s const*)
static bool		getEmitMode (const patch_t *patch)
{
	bool emitmode = false;
	vec_t value = 
#ifdef HLRAD_REFLECTIVITY
		DotProduct (patch->baselight, patch->texturereflectivity) / 3
#else
		VectorAvg (patch->baselight)
#endif
		;
#ifdef HLRAD_CUSTOMTEXLIGHT
	if (g_face_texlights[patch->faceNumber])
	{
		if (*ValueForKey (g_face_texlights[patch->faceNumber], "_scale"))
		{
			value *= FloatForKey (g_face_texlights[patch->faceNumber], "_scale");
		}
	}
#endif
	if (value > 0.0)
	{
		emitmode = true;
	}
	if (value < g_dlight_threshold)
	{
		emitmode = false;
	}
#ifdef HLRAD_CUSTOMTEXLIGHT
	if (g_face_texlights[patch->faceNumber])
	{
		switch (IntForKey (g_face_texlights[patch->faceNumber], "_fast"))
		{
		case 1:
			emitmode = false;
			break;
		case 2:
			emitmode = true;
			break;
		}
	}
#endif
	return emitmode;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x10(%rsp), %rax
movss 0xf8(%rax), %xmm1
movq 0x10(%rsp), %rax
movss 0x70(%rax), %xmm2
movq 0x10(%rsp), %rax
movss 0xfc(%rax), %xmm0
movq 0x10(%rsp), %rax
mulss 0x74(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x10(%rsp), %rax
movss 0x100(%rax), %xmm0
movq 0x10(%rsp), %rax
movss 0x78(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x169a1(%rip), %xmm1    # 0x6db9c
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x53967fb(%rip), %rax   # 0x53eda10
cmpq $0x0, (%rax,%rcx,8)
je 0x5726f
movq 0x10(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x53967e4(%rip), %rax   # 0x53eda10
movq (%rax,%rcx,8), %rdi
leaq 0x16d15(%rip), %rsi     # 0x6df4c
callq 0x7d50
cmpb $0x0, (%rax)
je 0x5726d
movq 0x10(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x53967bf(%rip), %rax   # 0x53eda10
movq (%rax,%rcx,8), %rdi
leaq 0x16cf0(%rip), %rsi     # 0x6df4c
callq 0x8b40
mulss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x5726f
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x57287
movb $0x1, 0xf(%rsp)
movss 0x8(%rsp), %xmm1
movss 0x2714b(%rip), %xmm0    # 0x7e3e0
ucomiss %xmm1, %xmm0
jbe 0x5729f
movb $0x0, 0xf(%rsp)
movq 0x10(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x5396761(%rip), %rax   # 0x53eda10
cmpq $0x0, (%rax,%rcx,8)
je 0x572fc
movq 0x10(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x539674a(%rip), %rax   # 0x53eda10
movq (%rax,%rcx,8), %rdi
leaq 0x16ce5(%rip), %rsi     # 0x6dfb6
callq 0x7f70
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
subl $0x1, %eax
je 0x572ee
jmp 0x572e3
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x572f5
jmp 0x572fa
movb $0x0, 0xf(%rsp)
jmp 0x572fa
movb $0x1, 0xf(%rsp)
jmp 0x572fc
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: getChop(patch_s const*)
static vec_t    getChop(const patch_t* const patch)
{
    vec_t           rval;

#ifdef HLRAD_CUSTOMTEXLIGHT
	if (g_face_texlights[patch->faceNumber])
	{
		if (*ValueForKey (g_face_texlights[patch->faceNumber], "_chop"))
		{
			rval = FloatForKey (g_face_texlights[patch->faceNumber], "_chop");
			if (rval < 1.0)
			{
				rval = 1.0;
			}
			return rval;
		}
	}
#endif
#ifdef HLRAD_TEXLIGHTTHRESHOLD_FIX
	if (!patch->emitmode)
#else
    if (VectorCompare(patch->baselight, vec3_origin))
#endif
    {
        rval = g_chop * getScale(patch);
    }
    else
    {
        rval = g_texchop * getScale(patch);
#ifdef HLRAD_ACCURATEBOUNCE_TEXLIGHT
		// we needn't do this now, so let's save our compile time.
#else
        if (g_extra)
        {
            rval *= 0.5;
        }
#endif
    }

#ifdef HLRAD_CUSTOMCHOP
	rval *= ChopScaleForTexture (patch->faceNumber);
#endif
    return rval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x5396357(%rip), %rax   # 0x53eda10
cmpq $0x0, (%rax,%rcx,8)
je 0x57748
movq 0x18(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x539633c(%rip), %rax   # 0x53eda10
movq (%rax,%rcx,8), %rdi
leaq 0x1a0dc(%rip), %rsi     # 0x717bb
callq 0x7d50
cmpb $0x0, (%rax)
je 0x57746
movq 0x18(%rsp), %rax
movslq 0x58(%rax), %rcx
leaq 0x5396317(%rip), %rax   # 0x53eda10
movq (%rax,%rcx,8), %rdi
leaq 0x1a0b7(%rip), %rsi     # 0x717bb
callq 0x8b40
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x15ac7(%rip), %xmm0    # 0x6d1e8
ucomisd %xmm1, %xmm0
jbe 0x57735
movss 0x1291d(%rip), %xmm0    # 0x6a04c
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x577d3
jmp 0x57748
movq 0x18(%rsp), %rax
testb $0x1, 0x104(%rax)
jne 0x57783
movss 0x26cda(%rip), %xmm0    # 0x7e438
movss %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x57310
movaps %xmm0, %xmm1
movss 0x10(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x577ae
movss 0x26cb1(%rip), %xmm0    # 0x7e43c
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x57310
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x58(%rax), %edi
callq 0x4e7a0
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: LightForTexture(char const*, float*)
static void     LightForTexture(const char* const name, vec3_t result)
{
    texlight_i it;
    for (it = s_texlights.begin(); it != s_texlights.end(); it++)
    {
        if (!strcasecmp(name, it->name.c_str()))
        {
            VectorCopy(it->value, result);
            return;
        }
    }
    VectorClear(result);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5b820
leaq 0x55177e1(%rip), %rdi   # 0x556fb80
callq 0x5b840
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x55177c6(%rip), %rdi   # 0x556fb80
callq 0x5b8b0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5b870
testb $0x1, %al
jne 0x583dc
jmp 0x5846c
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5b8e0
movq %rax, %rdi
callq 0x4150
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4350
cmpl $0x0, %eax
jne 0x58454
leaq 0x20(%rsp), %rdi
callq 0x5b8e0
movss 0x20(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x5b8e0
movss 0x24(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x4(%rax)
leaq 0x20(%rsp), %rdi
callq 0x5b8e0
movss 0x28(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x8(%rax)
jmp 0x58492
jmp 0x58456
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x5b9a0
movq %rax, 0x8(%rsp)
jmp 0x583b3
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: patch_sorter(void const*, void const*)
static int CDECL patch_sorter(const void* p1, const void* p2)
{
    patch_t*        patch1 = (patch_t*)p1;
    patch_t*        patch2 = (patch_t*)p2;

    if (patch1->faceNumber < patch2->faceNumber)
    {
        return -1;
    }
    else if (patch1->faceNumber > patch2->faceNumber)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0x58(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jge 0x5935a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x5937e
movq -0x20(%rsp), %rax
movl 0x58(%rax), %eax
movq -0x28(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jle 0x59376
movl $0x1, -0x4(%rsp)
jmp 0x5937e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qrad.cpp
// Function: WriteWorld(char const*)
static void     WriteWorld(const char* const name)
{
    unsigned        i;
    unsigned        j;
    FILE*           out;
    patch_t*        patch;
    Winding*        w;

    out = fopen(name, "w");

    if (!out)
        Error("Couldn't open %s", name);

    for (j = 0, patch = g_patches; j < g_num_patches; j++, patch++)
    {
        w = patch->winding;
        Log("%i\n", w->m_NumPoints);
        for (i = 0; i < w->m_NumPoints; i++)
        {
#ifdef ZHLT_TEXLIGHT
            Log("%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
                w->m_Points[i][0],
                w->m_Points[i][1],
                w->m_Points[i][2], patch->totallight[0][0] / 256, patch->totallight[0][1] / 256, patch->totallight[0][2] / 256); //LRC
#else
            Log("%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
                w->m_Points[i][0],
                w->m_Points[i][1],
                w->m_Points[i][2], patch->totallight[0] / 256, patch->totallight[1] / 256, patch->totallight[2] / 256);
#endif
        }
        Log("\n");
    }

    fclose(out);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1587e(%rip), %rsi     # 0x70d83
callq 0x4390
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5b52a
movq 0x20(%rsp), %rsi
leaq 0x13065(%rip), %rdi     # 0x6e588
movb $0x0, %al
callq 0xb580
movl $0x0, 0x18(%rsp)
movq 0x53924c7(%rip), %rax   # 0x53eda00
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x54124c0(%rip), %eax   # 0x546da08
jae 0x5b67f
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x8(%rax), %esi
leaq 0x11c5f(%rip), %rdi     # 0x6d1c8
movb $0x0, %al
callq 0xb0d0
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x5b651
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
movq 0x8(%rsp), %rax
movss 0x90(%rax), %xmm3
movss 0x125d3(%rip), %xmm4    # 0x6dbc4
divss %xmm4, %xmm3
cvtss2sd %xmm3, %xmm3
movq 0x8(%rsp), %rax
movss 0x94(%rax), %xmm4
movss 0x125b6(%rip), %xmm5    # 0x6dbc4
divss %xmm5, %xmm4
cvtss2sd %xmm4, %xmm4
movq 0x8(%rsp), %rax
movss 0x98(%rax), %xmm5
movss 0x12599(%rip), %xmm6    # 0x6dbc4
divss %xmm6, %xmm5
cvtss2sd %xmm5, %xmm5
leaq 0x1621f(%rip), %rdi     # 0x71859
movb $0x6, %al
callq 0xb0d0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5b578
leaq 0x106a0(%rip), %rdi     # 0x6bcf8
movb $0x0, %al
callq 0xb0d0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x138, %rax            # imm = 0x138
movq %rax, 0x8(%rsp)
jmp 0x5b53e
movq 0x10(%rsp), %rdi
callq 0x4310
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: PointInLeaf(float const*)
dleaf_t*        PointInLeaf(const vec3_t point)
{
    int             nodenum;
    vec_t           dist;
    dnode_t*        node;
    dplane_t*       plane;

    nodenum = 0;
    while (nodenum >= 0)
    {
        node = &g_dnodes[nodenum];
        plane = &g_dplanes[node->planenum];
        dist = DotProduct(point, plane->normal) - plane->dist;
        if (dist >= 0.0)
        {
            nodenum = node->children[0];
        }
        else
        {
            nodenum = node->children[1];
        }
    }

    return &g_dleafs[-nodenum - 1];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x5cd39
movslq -0xc(%rsp), %rcx
leaq 0x10c978c(%rip), %rax   # 0x1126410
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movslq (%rax), %rcx
leaq 0xb09761(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movss (%rax), %xmm1
movq -0x20(%rsp), %rax
movss (%rax), %xmm2
movq -0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rsp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
movq -0x20(%rsp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rsp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x10(%rsp)
movss -0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5cd27
movq -0x18(%rsp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0xc(%rsp)
jmp 0x5cd34
movq -0x18(%rsp), %rax
movswl 0x6(%rax), %eax
movl %eax, -0xc(%rsp)
jmp 0x5cc6d
xorl %eax, %eax
subl -0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xa29784(%rip), %rax    # 0xa864d0
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: getPlaneFromFaceNumber(unsigned int)
const dplane_t* getPlaneFromFaceNumber(const unsigned int faceNumber)
{
    dface_t*        face = &g_dfaces[faceNumber];

    if (face->side)
    {
        return &backplanes[face->planenum];
    }
    else
    {
        return &g_dplanes[face->planenum];
    }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x1b895ef(%rip), %rax   # 0x1be6410
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpw $0x0, 0x2(%rax)
je 0x5ce58
movq -0x18(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
leaq 0x5532da6(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x5ce75
movq -0x18(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
leaq 0xb09597(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: MakeBackplanes()
void            MakeBackplanes()
{
    int             i;

    for (i = 0; i < g_numplanes; i++)
    {
        backplanes[i].dist = -g_dplanes[i].dist;
        VectorSubtract(vec3_origin, g_dplanes[i].normal, backplanes[i].normal);
    }
}

// Assembly:
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
leaq 0xb09561(%rip), %rcx    # 0xb663f4
cmpl (%rcx), %eax
jge 0x5cf99
movslq -0x4(%rsp), %rcx
leaq 0xb09559(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movss 0xc(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x5532d24(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0xc(%rax)
leaq 0xef71(%rip), %rax      # 0x6be50
movss (%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xb09511(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
subss (%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x5532cea(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
leaq 0xef38(%rip), %rax      # 0x6be50
movss 0x4(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xb094d7(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
subss 0x4(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x5532caf(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0x4(%rax)
leaq 0xeefc(%rip), %rax      # 0x6be50
movss 0x8(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0xb0949b(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
subss 0x8(%rax), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x5532c73(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0x8(%rax)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x5ce88
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: getPlaneFromFace(dface_t const*)
const dplane_t* getPlaneFromFace(const dface_t* const face)
{
    if (!face)
    {
        Error("getPlaneFromFace() face was NULL\n");
    }

    if (face->side)
    {
        return &backplanes[face->planenum];
    }
    else
    {
        return &g_dplanes[face->planenum];
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5cfbf
leaq 0x14908(%rip), %rdi     # 0x718c0
movb $0x0, %al
callq 0xb580
movq 0x8(%rsp), %rax
cmpw $0x0, 0x2(%rax)
je 0x5cfea
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
leaq 0x5532c14(%rip), %rax   # 0x558fbf0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x5d007
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %ecx
leaq 0xb09405(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: ApplyMatrix(matrix_t const&, float const*, float (&) [3])
void ApplyMatrix (const matrix_t &m, const vec3_t in, vec3_t &out)
{
	int i;

	hlassume (&in[0] != &out[0], assume_first);
	VectorCopy (m.v[3], out);
	for (i = 0; i < 3; i++)
	{
		VectorMA (out, in[i], m.v[i], out);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
setne %al
movzbl %al, %edi
andl $0x1, %edi
xorl %esi, %esi
callq 0xbf00
movq 0x20(%rsp), %rax
movss 0x24(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, (%rax)
movq 0x20(%rsp), %rax
movss 0x28(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
movss 0x2c(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x8(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x5da6e
movq 0x10(%rsp), %rax
movss (%rax), %xmm1
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss (%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, (%rax)
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm1
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x4(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x10(%rsp), %rax
movss 0x8(%rax), %xmm1
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5d993
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: ApplyMatrixOnPlane(matrix_t const&, float const*, float, float (&) [3], float&)
void ApplyMatrixOnPlane (const matrix_t &m_inverse, const vec3_t in_normal, vec_t in_dist, vec3_t &out_normal, vec_t &out_dist)
	// out_normal is not normalized
{
	int i;
	
	hlassume (&in_normal[0] != &out_normal[0], assume_first);
	for (i = 0; i < 3; i++)
	{
		out_normal[i] = DotProduct (in_normal, m_inverse.v[i]);
	}
	out_dist = - (DotProduct (in_normal, m_inverse.v[3]) - in_dist);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
setne %al
movzbl %al, %edi
andl $0x1, %edi
xorl %esi, %esi
callq 0xbf00
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x5db5b
movq 0x28(%rsp), %rax
movss (%rax), %xmm1
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss (%rax), %xmm2
movq 0x28(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x28(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5dac3
movq 0x28(%rsp), %rax
movss (%rax), %xmm1
movq 0x30(%rsp), %rax
movss 0x24(%rax), %xmm2
movq 0x28(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x30(%rsp), %rax
mulss 0x28(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x28(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movss 0x2c(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
subss 0x24(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, (%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: MultiplyMatrix(matrix_t const&, matrix_t const&, matrix_t&)
void MultiplyMatrix (const matrix_t &m_left, const matrix_t &m_right, matrix_t &m)
	// The following two processes are equivalent:
	//  1) ApplyMatrix (m1, v_in, v_temp), ApplyMatrix (m2, v_temp, v_out);
	//  2) MultiplyMatrix (m2, m1, m), ApplyMatrix (m, v_in, v_out);
{
	int i, j;
	const vec_t lastrow[4] = {0, 0, 0, 1};
	
	hlassume (&m != &m_left && &m != &m_right, assume_first);
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			m.v[j][i] = m_left.v[0][i] * m_right.v[j][0]
					  + m_left.v[1][i] * m_right.v[j][1]
					  + m_left.v[2][i] * m_right.v[j][2]
					  + m_left.v[3][i] * lastrow[j];
		}
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x13cc6(%rip), %rax     # 0x718b0
movq %rax, 0x10(%rsp)
movq 0x13cc2(%rip), %rax     # 0x718b8
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
xorl %eax, %eax
cmpq 0x40(%rsp), %rcx
movb %al, 0xf(%rsp)
je 0x5dc1e
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
xorl %esi, %esi
callq 0xbf00
movl $0x0, 0x2c(%rsp)
cmpl $0x3, 0x2c(%rsp)
jge 0x5dd35
movl $0x0, 0x28(%rsp)
cmpl $0x4, 0x28(%rsp)
jge 0x5dd23
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss (%rax), %xmm2
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss 0xc(%rax,%rcx,4), %xmm1
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss 0x18(%rax,%rcx,4), %xmm1
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss 0x24(%rax,%rcx,4), %xmm0
movslq 0x28(%rsp), %rax
movss 0x10(%rsp,%rax,4), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x30(%rsp), %rax
movslq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq 0x2c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x5dc4a
jmp 0x5dd25
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5dc37
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: MatrixForScale(float const*, float, matrix_t&)
void MatrixForScale (const vec3_t center, vec_t scale, matrix_t &m)
{
	int i;

	for (i = 0; i < 3; i++)
	{
		VectorClear (m.v[i]);
		m.v[i][i] = scale;
	}
	VectorScale (center, 1 - scale, m.v[3]);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x3, -0x1c(%rsp)
jge 0x5de17
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movss -0xc(%rsp), %xmm0
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x5dd98
movq -0x8(%rsp), %rax
movss (%rax), %xmm0
movss 0xc224(%rip), %xmm1     # 0x6a04c
subss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
movq -0x18(%rsp), %rax
movss %xmm0, 0x24(%rax)
movq -0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
movss 0xc1fe(%rip), %xmm1     # 0x6a04c
subss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
movq -0x18(%rsp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
movss 0xc1d8(%rip), %xmm1     # 0x6a04c
subss -0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
movq -0x18(%rsp), %rax
movss %xmm0, 0x2c(%rax)
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlrad/qradutil.cpp
// Function: TranslateWorldToTex(int, matrix_t&)
void TranslateWorldToTex (int facenum, matrix_t &m)
	// without g_face_offset
{
	dface_t *f;
	texinfo_t *ti;
	const dplane_t *fp;
	int i;

	f = &g_dfaces[facenum];
	ti = &g_texinfo[f->texinfo];
	fp = getPlaneFromFace (f);
	for (i = 0; i < 3; i++)
	{
		m.v[i][0] = ti->vecs[0][i];
		m.v[i][1] = ti->vecs[1][i];
		m.v[i][2] = fp->normal[i];
	}
	m.v[3][0] = ti->vecs[0][3];
	m.v[3][1] = ti->vecs[1][i];
	m.v[3][2] = -fp->dist;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movslq 0x34(%rsp), %rcx
leaq 0x1b88417(%rip), %rax   # 0x1be6410
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movswq 0xa(%rax), %rcx
leaq 0x11883ea(%rip), %rax   # 0x11e6400
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5cfa0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x5e0bf
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss 0x10(%rax,%rcx,4), %xmm0
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0x4(%rax)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5e039
movq 0x18(%rsp), %rax
movss 0xc(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x24(%rax)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss 0x10(%rax,%rcx,4), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x28(%rax)
movq 0x10(%rsp), %rax
movss 0xc(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x2c(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/sparse.cpp
// Function: BuildVisMatrix()
static void     BuildVisMatrix()
{
    s_vismatrix = (sparse_column_t*)AllocBlock(g_num_patches * sizeof(sparse_column_t));

    if (!s_vismatrix)
    {
        Log("Failed to allocate vismatrix");
        hlassume(s_vismatrix != NULL, assume_NoMemory);
    }

#ifdef HLRAD_VIS_FIX
    NamedRunThreadsOn(g_dmodels[0].visleafs, g_estimate, BuildVisLeafs);
#else
    NamedRunThreadsOn(g_numleafs - 1, g_estimate, BuildVisLeafs);
#endif
}

// Assembly:
pushq %rax
leaq 0x540c490(%rip), %rax   # 0x546da08
movl (%rax), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x47a0
movq %rax, 0x66ce554(%rip)   # 0x672fae0
cmpq $0x0, 0x66ce54c(%rip)   # 0x672fae0
jne 0x615bf
leaq 0x10527(%rip), %rdi     # 0x71ac4
movb $0x0, %al
callq 0xb0d0
cmpq $0x0, 0x66ce534(%rip)   # 0x672fae0
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbf00
leaq 0x1051b(%rip), %rdi     # 0x71ae1
callq 0xb2f0
movq %rax, %rsi
leaq 0xd0c8(%rip), %rdi      # 0x6e69d
movb $0x0, %al
callq 0xb0d0
leaq 0x1ce9d(%rip), %rax     # 0x7e480
movl 0x34(%rax), %edi
leaq 0x1ce47(%rip), %rax     # 0x7e434
movb (%rax), %al
leaq 0x2da(%rip), %rdx       # 0x618d0
andb $0x1, %al
movzbl %al, %esi
callq 0xd2a0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/sparse.cpp
// Function: DumpVismatrixInfo()
static void     DumpVismatrixInfo()
{
    unsigned        totals[8];
#ifdef ZHLT_64BIT_FIX
    size_t          total_vismatrix_memory;
#else
    unsigned        total_vismatrix_memory;
#endif
	total_vismatrix_memory = sizeof(sparse_column_t) * g_num_patches;

    sparse_column_t* column_end = s_vismatrix + g_num_patches;
    sparse_column_t* column = s_vismatrix;

    memset(totals, 0, sizeof(totals));

    while (column < column_end)
    {
        total_vismatrix_memory += column->count * sizeof(sparse_row_t);
        column++;
    }

    Log("%-20s: %5.1f megs\n", "visibility matrix", total_vismatrix_memory / (1024 * 1024.0));
}

// Assembly:
subq $0x48, %rsp
leaq 0x540c3ed(%rip), %rax   # 0x546da08
movl (%rax), %eax
shlq $0x4, %rax
movq %rax, 0x18(%rsp)
movq 0x66ce4b3(%rip), %rax   # 0x672fae0
leaq 0x540c3d4(%rip), %rcx   # 0x546da08
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x66ce497(%rip), %rax   # 0x672fae0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x41b0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x61692
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
shlq $0x2, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x6165f
movaps 0x103f7(%rip), %xmm1    # 0x71a90
movq 0x18(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x103f5(%rip), %xmm1    # 0x71aa0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xa19e(%rip), %xmm1     # 0x6b860
divsd %xmm1, %xmm0
leaq 0x104af(%rip), %rdi     # 0x71b7c
leaq 0x104bb(%rip), %rsi     # 0x71b8f
movb $0x1, %al
callq 0xb0d0
addq $0x48, %rsp
retq
// File: FreeSlave[P]vhlt/hlrad/sparse.cpp
// Function: CheckVisBitSparse(unsigned int, unsigned int, float (&) [3], unsigned int&)
static bool     CheckVisBitSparse(unsigned x, unsigned y
#ifdef HLRAD_HULLU
								  , vec3_t &transparency_out
								  , unsigned int &next_index
#endif
								  )
{
#ifdef HLRAD_HULLU
    int                offset;
#else
    unsigned        offset;
#endif

#ifdef HLRAD_HULLU
    	VectorFill(transparency_out, 1.0);
#endif

    if (x == y)
    {
        return 1;
    }

#ifdef HLRAD_HULLU
    const unsigned a = x;
    const unsigned b = y;
#endif

    if (x > y)
    {
#ifndef HLRAD_HULLU
        const unsigned a = x;
        const unsigned b = y;
#endif
        x = b;
        y = a;
    }

    if (x > g_num_patches)
    {
        Warning("in CheckVisBit(), x > num_patches");
    }
    if (y > g_num_patches)
    {
        Warning("in CheckVisBit(), y > num_patches");
    }

    if ((offset = IsVisbitInArray(x, y)) != -1)
    {
#ifdef HLRAD_HULLU
    	if(g_customshadow_with_bouncelight)
    	{
    	     GetTransparency(a, b, transparency_out, next_index);
    	}
#endif
        return s_vismatrix[x].row[offset].values & (1 << (y & 7));
    }

	return false;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss 0x8949(%rip), %xmm0     # 0x6a04c
movss %xmm0, (%rax)
movq 0x20(%rsp), %rax
movss 0x8938(%rip), %xmm0     # 0x6a04c
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
movss 0x8926(%rip), %xmm0     # 0x6a04c
movss %xmm0, 0x8(%rax)
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x6173f
movb $0x1, 0x37(%rsp)
jmp 0x61821
movl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x61769
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x30(%rsp), %eax
leaq 0x540c294(%rip), %rcx   # 0x546da08
cmpl (%rcx), %eax
jbe 0x61786
leaq 0x10422(%rip), %rdi     # 0x71ba1
movb $0x0, %al
callq 0xb9f0
movl 0x2c(%rsp), %eax
leaq 0x540c277(%rip), %rcx   # 0x546da08
cmpl (%rcx), %eax
jbe 0x617a3
leaq 0x10427(%rip), %rdi     # 0x71bc3
movb $0x0, %al
callq 0xb9f0
movl 0x30(%rsp), %edi
movl 0x2c(%rsp), %esi
callq 0x622b0
movl %eax, 0x14(%rsp)
cmpl $-0x1, %eax
je 0x6181c
leaq 0x54ce288(%rip), %rax   # 0x552fa48
testb $0x1, (%rax)
je 0x617dc
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x662b0
movq 0x66ce2fd(%rip), %rax   # 0x672fae0
movl 0x30(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
movl 0x2c(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x61821
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlrad/sparse.cpp
// Function: FreeVisMatrix()
static void     FreeVisMatrix()
{
    if (s_vismatrix)
    {
        unsigned        x;
        sparse_column_t* item;

        for (x = 0, item = s_vismatrix; x < g_num_patches; x++, item++)
        {
            if (item->row)
            {
                free(item->row);
            }
        }
        if (FreeBlock(s_vismatrix))
        {
            s_vismatrix = NULL;
        }
        else
        {
            Warning("Unable to free vismatrix");
        }
    }

#ifndef HLRAD_TRANSPARENCY_CPP
#ifdef HLRAD_HULLU
    if(s_transparency_list)
    {
    	free(s_transparency_list);
    	s_transparency_list = NULL;
    }
    s_transparency_count = s_max_transparency_count = 0;    
#endif
#endif

}

// Assembly:
subq $0x18, %rsp
cmpq $0x0, 0x66ce2a4(%rip)   # 0x672fae0
je 0x618c9
movl $0x0, 0x14(%rsp)
movq 0x66ce28f(%rip), %rax   # 0x672fae0
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
leaq 0x540c1a7(%rip), %rcx   # 0x546da08
cmpl (%rcx), %eax
jae 0x6189a
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x6187d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x43a0
jmp 0x6187f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x61856
movq 0x66ce23f(%rip), %rdi   # 0x672fae0
callq 0x47d0
testb $0x1, %al
jne 0x618ac
jmp 0x618b9
movq $0x0, 0x66ce229(%rip) # 0x672fae0
jmp 0x618c7
leaq 0x10325(%rip), %rdi     # 0x71be5
movb $0x0, %al
callq 0xb9f0
jmp 0x618c9
addq $0x18, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/sparse.cpp
// Function: IsVisbitInArray(unsigned int, unsigned int)
static unsigned IsVisbitInArray(const unsigned x, const unsigned y)
{
    int             first, last, current;
    int             y_byte = y / 8;
    sparse_row_t*  row;
    sparse_column_t* column = s_vismatrix + x;

    if (!column->count)
    {
        return -1;
    }

    first = 0;
    last = column->count - 1;

    //    Warning("Searching . . .");
    // binary search to find visbit
    while (1)
    {
        current = (first + last) / 2;
        row = column->row + current;
        //        Warning("first %u, last %u, current %u, row %p, row->offset %u", first, last, current, row, row->offset);
        if ((row->offset) < y_byte)
        {
            first = current + 1;
        }
        else if ((row->offset) > y_byte)
        {
            last = current - 1;
        }
        else
        {
            return current;
        }
        if (first > last)
        {
            return -1;
        }
    }
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
shrl $0x3, %eax
movl %eax, -0x1c(%rsp)
movq 0x66cd816(%rip), %rax   # 0x672fae0
movl -0x8(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x622f2
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x62399
movl $0x0, -0x10(%rsp)
movq -0x30(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
addl -0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rsp)
movq -0x30(%rsp), %rax
movq (%rax), %rax
movslq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl (%rax), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
cmpl -0x1c(%rsp), %eax
jge 0x62355
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x62380
movq -0x28(%rsp), %rax
movl (%rax), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
cmpl -0x1c(%rsp), %eax
jle 0x62374
movl -0x18(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x6237e
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x62399
jmp 0x62380
movl -0x10(%rsp), %eax
cmpl -0x14(%rsp), %eax
jle 0x62394
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x62399
jmp 0x62309
movl -0x4(%rsp), %eax
retq
nop
// File: FreeSlave[P]vhlt/hlrad/trace.cpp
// Function: MakeTnodes(dmodel_t*)
void            MakeTnodes(dmodel_t* /*bm*/)
{
    // 32 byte align the structs
    tnodes = (tnode_t*)calloc((g_numnodes + 1), sizeof(tnode_t));

	// The alignment doesn't have any effect at all. --vluzacn
#ifdef ZHLT_64BIT_FIX
	int ofs = 31 - (int)(((uintptr_t)tnodes + (uintptr_t)31) & (uintptr_t)31);
	tnodes = (tnode_t *)((byte *)tnodes + ofs);
#else
    tnodes = (tnode_t*)(((int)tnodes + 31) & ~31);
#endif
    tnode_p = tnodes;

    MakeTnode(0);
#if 0 //debug. vluzacn
	ViewTNode ();
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x10c4058(%rip), %rax   # 0x1126408
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x20, %esi
callq 0x4220
movq %rax, 0x66cd71f(%rip)   # 0x672fae8
movq 0x66cd718(%rip), %rax   # 0x672fae8
addq $0x1f, %rax
andq $0x1f, %rax
movl %eax, %ecx
movl $0x1f, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x66cd6fc(%rip), %rax   # 0x672fae8
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x66cd6ed(%rip)   # 0x672fae8
movq 0x66cd6e6(%rip), %rax   # 0x672fae8
movq %rax, 0x66cd6e7(%rip)   # 0x672faf0
xorl %edi, %edi
callq 0x62420
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlrad/trace.cpp
// Function: MakeTnode(int)
static void     MakeTnode(const int nodenum)
{
    tnode_t*        t;
    dplane_t*       plane;
    int             i;
    dnode_t*        node;

    t = tnode_p++;

    node = g_dnodes + nodenum;
    plane = g_dplanes + node->planenum;

    t->type = plane->type;
    VectorCopy(plane->normal, t->normal);
#ifdef ZHLT_PLANETYPE_FIX //debug
	if (plane->normal[(plane->type)%3] < 0)
		if (plane->type < 3)
			Warning ("MakeTnode: negative plane");
		else
			Developer (DEVELOPER_LEVEL_MESSAGE, "Warning: MakeTnode: negative plane\n");
#endif
    t->dist = plane->dist;

    for (i = 0; i < 2; i++)
    {
        if (node->children[i] < 0)
            t->children[i] = g_dleafs[-node->children[i] - 1].contents;
        else
        {
            t->children[i] = tnode_p - tnodes;
            MakeTnode(node->children[i]);
        }
    }

}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq 0x66cd6c1(%rip), %rax   # 0x672faf0
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x66cd6b3(%rip)   # 0x672faf0
movq %rax, 0x28(%rsp)
movslq 0x34(%rsp), %rcx
leaq 0x10c3fc2(%rip), %rax   # 0x1126410
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq (%rax), %rcx
leaq 0xb03f97(%rip), %rax    # 0xb66400
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0xc(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movq 0x8(%rsp), %rax
movslq %edx, %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x6251a
movq 0x20(%rsp), %rax
cmpl $0x3, 0x10(%rax)
jge 0x62505
leaq 0xf7ab(%rip), %rdi      # 0x71ca7
movb $0x0, %al
callq 0xb9f0
jmp 0x62518
movl $0x3, %edi
leaq 0xf7b0(%rip), %rsi      # 0x71cc1
movb $0x0, %al
callq 0xbbf0
jmp 0x6251a
movq 0x20(%rsp), %rax
movss 0xc(%rax), %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, 0x10(%rax)
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x625d9
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movswl 0x4(%rax,%rcx,2), %eax
cmpl $0x0, %eax
jge 0x6258e
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movswl 0x4(%rax,%rcx,2), %ecx
xorl %eax, %eax
subl %ecx, %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xa23f5b(%rip), %rax    # 0xa864d0
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, 0x14(%rax,%rcx,4)
jmp 0x625c7
movq 0x66cd55b(%rip), %rax   # 0x672faf0
movq 0x66cd54c(%rip), %rcx   # 0x672fae8
subq %rcx, %rax
sarq $0x5, %rax
movl %eax, %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, 0x14(%rax,%rcx,4)
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movswl 0x4(%rax,%rcx,2), %edi
callq 0x62420
jmp 0x625c9
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x62536
addq $0x38, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlrad/trace.cpp
// Function: MergeOpaqueFaces(int, int)
int MergeOpaqueFaces (int firstface, int numfaces)
{
	int i, j, newnum;
	opaqueface_t *faces = &opaquefaces[firstface];
	for (i = 0; i < numfaces; i++)
	{
		for (j = 0; j < i; j++)
		{
			if (TryMerge (&faces[i], &faces[j]))
			{
				delete faces[j].winding;
				faces[j].winding = NULL;
				j = -1;
				continue;
			}
		}
	}
	for (i = 0, j = 0; i < numfaces; i++)
	{
		if (faces[i].winding)
		{
			faces[j] = faces[i];
			j++;
		}
	}
	newnum = j;
	for (; j < numfaces; j++)
	{
		memset (&faces[j], 0, sizeof(opaqueface_t));
	}
	return newnum;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq 0x66cc115(%rip), %rax   # 0x672faf8
movslq 0x24(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x63abb
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x63aa9
movq 0x8(%rsp), %rdi
movslq 0x1c(%rsp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
movslq 0x18(%rsp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rsi
callq 0x62bb0
testb $0x1, %al
jne 0x63a4d
jmp 0x63a97
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x63a75
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
jmp 0x63a99
jmp 0x63a99
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x63a12
jmp 0x63aab
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x639fc
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x63b32
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x63b23
movq 0x8(%rsp), %rsi
movslq 0x1c(%rsp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rsi
movq 0x8(%rsp), %rdi
movslq 0x18(%rsp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rdi
movl $0x60, %edx
callq 0x4280
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x63b25
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x63acb
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x63b6e
movq 0x8(%rsp), %rdi
movslq 0x18(%rsp), %rax
imulq $0x60, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x41b0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x63b3a
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)