LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: LogArgs(int, char**)
static void     LogArgs(int argc, char** argv)
{
    int             i;

    Log("Command line: ");
    for (i = 0; i < argc; i++)
    {
        if (strchr(argv[i], ' '))
        {
            Log("\"%s\" ", argv[i]); //Log("\"%s\"", argv[i]); //--vluzacn
        }
        else
        {
            Log("%s ", argv[i]);
        }
    }
    Log("\n");
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x1fbd0(%rip), %rdi     # 0x2be34
movb $0x0, %al
callq 0xb5d0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xc2e4
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x20, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc2b9
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1fb93(%rip), %rdi     # 0x2be43
movb $0x0, %al
callq 0xb5d0
jmp 0xc2d5
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1fb7b(%rip), %rdi     # 0x2be49
movb $0x0, %al
callq 0xb5d0
jmp 0xc2d7
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc273
leaq 0x1fa4d(%rip), %rdi     # 0x2bd38
movb $0x0, %al
callq 0xb5d0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: DisplayDeveloperLevel()
static void     DisplayDeveloperLevel()
{
    char            message[MAX_MESSAGE];

    safe_strncpy(message, "Developer messages enabled : [", MAX_MESSAGE);
    if (g_developer >= DEVELOPER_LEVEL_MEGASPAM)
    {
        safe_strncat(message, "MegaSpam ", MAX_MESSAGE);
    }
    if (g_developer >= DEVELOPER_LEVEL_SPAM)
    {
        safe_strncat(message, "Spam ", MAX_MESSAGE);
    }
    if (g_developer >= DEVELOPER_LEVEL_FLUFF)
    {
        safe_strncat(message, "Fluff ", MAX_MESSAGE);
    }
    if (g_developer >= DEVELOPER_LEVEL_MESSAGE)
    {
        safe_strncat(message, "Message ", MAX_MESSAGE);
    }
    if (g_developer >= DEVELOPER_LEVEL_WARNING)
    {
        safe_strncat(message, "Warning ", MAX_MESSAGE);
    }
    if (g_developer >= DEVELOPER_LEVEL_ERROR)
    {
        safe_strncat(message, "Error", MAX_MESSAGE);
    }
    if (g_developer)
    {
        safe_strncat(message, "]\n", MAX_MESSAGE);
        Log(message);
    }
}

// Assembly:
subq $0x808, %rsp            # imm = 0x808
movq %rsp, %rdi
leaq 0x1fb3c(%rip), %rsi     # 0x2be4d
movl $0x800, %edx            # imm = 0x800
callq 0x9af0
cmpl $0x6, 0x20c119e(%rip)   # 0x20cd4c0
jl 0xc338
movq %rsp, %rdi
leaq 0x1fb3e(%rip), %rsi     # 0x2be6c
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x5, 0x20c1181(%rip)   # 0x20cd4c0
jl 0xc355
movq %rsp, %rdi
leaq 0x1fb25(%rip), %rsi     # 0x2be70
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x4, 0x20c1164(%rip)   # 0x20cd4c0
jl 0xc372
movq %rsp, %rdi
leaq 0x1fb0e(%rip), %rsi     # 0x2be76
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x3, 0x20c1147(%rip)   # 0x20cd4c0
jl 0xc38f
movq %rsp, %rdi
leaq 0x1faf8(%rip), %rsi     # 0x2be7d
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x2, 0x20c112a(%rip)   # 0x20cd4c0
jl 0xc3ac
movq %rsp, %rdi
leaq 0x1fae4(%rip), %rsi     # 0x2be86
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x1, 0x20c110d(%rip)   # 0x20cd4c0
jl 0xc3c9
movq %rsp, %rdi
leaq 0x20a45(%rip), %rsi     # 0x2ce04
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
cmpl $0x0, 0x20c10f0(%rip)   # 0x20cd4c0
je 0xc3f0
movq %rsp, %rdi
leaq 0x23370(%rip), %rsi     # 0x2f74c
movl $0x800, %edx            # imm = 0x800
callq 0x9b30
movq %rsp, %rdi
movb $0x0, %al
callq 0xb5d0
addq $0x808, %rsp            # imm = 0x808
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: hlassume(bool, assume_msgs)
void            hlassume(bool exp, assume_msgs msgid)
{
    if (!exp)
    {
        char            message[MAX_MESSAGE];
        const MessageTable_t* msg = GetAssume(msgid);

#ifdef ZHLT_LANGFILE
        safe_snprintf(message, MAX_MESSAGE, "%s\n%s%s\n%s%s\n", Localize (msg->title), Localize ("Description: "), Localize (msg->text), Localize ("Howto Fix: "), Localize (msg->howto));
#else
        safe_snprintf(message, MAX_MESSAGE, "%s\nDescription: %s\nHowto Fix: %s\n", msg->title, msg->text, msg->howto);
#endif
        Error(message);
    }
}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movb %dil, %al
andb $0x1, %al
movb %al, 0x847(%rsp)
movl %esi, 0x840(%rsp)
testb $0x1, 0x847(%rsp)
jne 0xc4d9
movl 0x840(%rsp), %edi
callq 0xcb00
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0xb7f0
movq %rax, 0x18(%rsp)
leaq 0x1f791(%rip), %rdi     # 0x2bbed
callq 0xb7f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xb7f0
movq %rax, 0x28(%rsp)
leaq 0x1f77b(%rip), %rdi     # 0x2bbfb
callq 0xb7f0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xb7f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x30(%rsp), %r10
movl $0x800, %esi            # imm = 0x800
leaq 0x1f722(%rip), %rdx     # 0x2bbdf
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x99e0
leaq 0x40(%rsp), %rdi
movb $0x0, %al
callq 0xba80
addq $0x848, %rsp            # imm = 0x848
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: LogTimeElapsed(float)
void LogTimeElapsed(float elapsed_time)
{
    unsigned days = 0;
    unsigned hours = 0;
    unsigned minutes = 0;
    unsigned seconds = 0;

    seconds_to_hhmm(elapsed_time, days, hours, minutes, seconds);

    if (days)
    {
        Log("%.2f seconds elapsed [%ud %uh %um %us]\n", elapsed_time, days, hours, minutes, seconds);
    }
    else if (hours)
    {
        Log("%.2f seconds elapsed [%uh %um %us]\n", elapsed_time, hours, minutes, seconds);
    }
    else if (minutes)
    {
        Log("%.2f seconds elapsed [%um %us]\n", elapsed_time, minutes, seconds);
    }
    else
    {
        Log("%.2f seconds elapsed\n", elapsed_time);
    }
}

// Assembly:
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cvttss2si 0x14(%rsp), %rax
movl %eax, %edi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0xc5f0
cmpl $0x0, 0x10(%rsp)
je 0xc56e
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
leaq 0x1f7d5(%rip), %rdi     # 0x2bd3a
movb $0x1, %al
callq 0xb5d0
jmp 0xc5e0
cmpl $0x0, 0xc(%rsp)
je 0xc59b
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %ecx
leaq 0x1f7d0(%rip), %rdi     # 0x2bd62
movb $0x1, %al
callq 0xb5d0
jmp 0xc5de
cmpl $0x0, 0x8(%rsp)
je 0xc5c4
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
leaq 0x1f7cb(%rip), %rdi     # 0x2bd86
movb $0x1, %al
callq 0xb5d0
jmp 0xc5dc
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1f7d1(%rip), %rdi     # 0x2bda6
movb $0x1, %al
callq 0xb5d0
jmp 0xc5de
jmp 0xc5e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: seconds_to_hhmm(unsigned int, unsigned int&, unsigned int&, unsigned int&, unsigned int&)
static void seconds_to_hhmm(unsigned int elapsed_time, unsigned& days, unsigned& hours, unsigned& minutes, unsigned& seconds)
{
    seconds = elapsed_time % 60;
    elapsed_time /= 60;

    minutes = elapsed_time % 60;
    elapsed_time /= 60;

    hours = elapsed_time % 24;
    elapsed_time /= 24;

    days = elapsed_time;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movl -0x4(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movq -0x28(%rsp), %rax
movl %edx, (%rax)
movl -0x4(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movq -0x20(%rsp), %rax
movl %edx, (%rax)
movl -0x4(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl $0x18, %ecx
xorl %edx, %edx
divl %ecx
movq -0x18(%rsp), %rax
movl %edx, (%rax)
movl -0x4(%rsp), %eax
movl $0x18, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: PrintConsole(char const*, ...)
void CDECL FORMAT_PRINTF(1,2) PrintConsole(const char* const warning, ...)
{
    char            message[MAX_MESSAGE];

    va_list         argptr;

    va_start(argptr, warning);
//ZHLT_LANGFILE: don't call function Localize here because of performance issue
    vsnprintf(message, MAX_MESSAGE, warning, argptr);
    va_end(argptr);

    if (useconsole)
	{
		fprintf (conout, "%s", message);
		fflush (conout);
	}
	else
	{
		fprintf (stdout, "%s", message);
	}
}

// Assembly:
subq $0x8d8, %rsp            # imm = 0x8D8
testb %al, %al
je 0xc6ec
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x8d0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x8e0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq 0xd0(%rsp), %rdi
movq 0x8d0(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0x800, %esi            # imm = 0x800
callq 0x4250
leaq 0xb0(%rsp), %rax
testb $0x1, 0x20c0d73(%rip)   # 0x20cd4d9
je 0xc793
movq 0x20c0d71(%rip), %rdi   # 0x20cd4e0
leaq 0xd0(%rsp), %rdx
leaq 0x1d987(%rip), %rsi     # 0x2a105
movb $0x0, %al
callq 0x4550
movq 0x20c0d54(%rip), %rdi   # 0x20cd4e0
callq 0x4450
jmp 0xc7b3
movq 0x29826(%rip), %rax     # 0x35fc0
movq (%rax), %rdi
leaq 0xd0(%rsp), %rdx
leaq 0x1d959(%rip), %rsi     # 0x2a105
movb $0x0, %al
callq 0x4550
addq $0x8d8, %rsp            # imm = 0x8D8
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: loadlangfileline(char*, int, _IO_FILE*)
int loadlangfileline (char *line, int n, FILE *f)
{
	int i = 0, c = 0;
	bool special = false;
	while (1)
	{
		c = fgetc (f);
		if (c == '\r')
			continue;
		if (c == '\n' || c == EOF)
			break;
		if (c == '\\' && !special)
		{
			special = true;
		}
		else
		{
			if (special)
			{
				switch (c)
				{
				case 'n': c = '\n'; break;
				case 't': c = '\t'; break;
				case 'v': c = '\v'; break;
				case 'b': c = '\b'; break;
				case 'r': c = '\r'; break;
				case 'f': c = '\f'; break;
				case 'a': c = '\a'; break;
				case '\\': c = '\\'; break;
				case '?': c = '\?'; break;
				case '\'': c = '\''; break;
				case '"': c = '\"'; break;
				default: break;
				}
			}
			if (i < n - 1)
				line[i++] = c;
			else
			{
				Warning ("line too long in localization file");
				break;
			}
			special = false;
		}
	}
	line[i] = '\0';
	if (c == EOF)
		return 1;
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x18(%rsp), %rdi
callq 0x45e0
movl %eax, 0x10(%rsp)
cmpl $0xd, 0x10(%rsp)
jne 0xc7fe
jmp 0xc7e7
cmpl $0xa, 0x10(%rsp)
je 0xc80c
cmpl $-0x1, 0x10(%rsp)
jne 0xc811
jmp 0xc919
cmpl $0x5c, 0x10(%rsp)
jne 0xc829
testb $0x1, 0xf(%rsp)
jne 0xc829
movb $0x1, 0xf(%rsp)
jmp 0xc914
testb $0x1, 0xf(%rsp)
je 0xc8d0
movl 0x10(%rsp), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x54, %eax
ja 0xc8cc
movq (%rsp), %rax
leaq 0x1f0eb(%rip), %rcx     # 0x2b940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, 0x10(%rsp)
jmp 0xc8ce
movl $0x9, 0x10(%rsp)
jmp 0xc8ce
movl $0xb, 0x10(%rsp)
jmp 0xc8ce
movl $0x8, 0x10(%rsp)
jmp 0xc8ce
movl $0xd, 0x10(%rsp)
jmp 0xc8ce
movl $0xc, 0x10(%rsp)
jmp 0xc8ce
movl $0x7, 0x10(%rsp)
jmp 0xc8ce
movl $0x5c, 0x10(%rsp)
jmp 0xc8ce
movl $0x3f, 0x10(%rsp)
jmp 0xc8ce
movl $0x27, 0x10(%rsp)
jmp 0xc8ce
movl $0x22, 0x10(%rsp)
jmp 0xc8ce
jmp 0xc8ce
jmp 0xc8d0
movl 0x14(%rsp), %eax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc8ff
movl 0x10(%rsp), %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xc90f
leaq 0x1f4b6(%rip), %rdi     # 0x2bdbc
movb $0x0, %al
callq 0xbef0
jmp 0xc919
movb $0x0, 0xf(%rsp)
jmp 0xc7e7
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $-0x1, 0x10(%rsp)
jne 0xc938
movl $0x1, 0x34(%rsp)
jmp 0xc940
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/log.cpp
// Function: LoadLangFile(char const*, char const*)
void LoadLangFile (const char *name, const char *programpath)
{
	char filepath[_MAX_PATH];
	char line1[MAXTOKEN];
	char line2[MAXTOKEN];
	FILE *f = NULL;
	if (!f)
	{
		strcpy (filepath, name);
		f = fopen (filepath, "r");
	}
	if (!f)
	{
		ExtractFilePath (programpath, filepath);
		strcat (filepath, name);
		f = fopen (filepath, "r");
	}
	if (!f)
	{
		Warning ("can not open file: '%s'", name);
		return;
	}
	while (1)
	{
		if (loadlangfileline (line1, MAXTOKEN, f) == 1)
			break;
		loadlangfileline (line2, MAXTOKEN, f);
		if (g_lang_count < g_lang_max)
		{
			g_lang[g_lang_count][0] = strdup (line1);
			g_lang[g_lang_count][1] = strdup (line2);
			g_lang_count++;
		}
		else
		{
			Warning ("too many lines in localization file");
			break;
		}
	}
	fclose (f);
	Log ("Localization file: '%s'\n", filepath);
}

// Assembly:
subq $0x3028, %rsp           # imm = 0x3028
movq %rdi, 0x3020(%rsp)
movq %rsi, 0x3018(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc9a6
leaq 0x2010(%rsp), %rdi
movq 0x3020(%rsp), %rsi
callq 0x4380
leaq 0x2010(%rsp), %rdi
leaq 0x2074c(%rip), %rsi     # 0x2d0e8
callq 0x4460
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc9f1
movq 0x3018(%rsp), %rdi
leaq 0x2010(%rsp), %rsi
callq 0x96d0
leaq 0x2010(%rsp), %rdi
movq 0x3020(%rsp), %rsi
callq 0x4670
leaq 0x2010(%rsp), %rdi
leaq 0x20701(%rip), %rsi     # 0x2d0e8
callq 0x4460
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xca14
movq 0x3020(%rsp), %rsi
leaq 0x1f3d7(%rip), %rdi     # 0x2bddf
movb $0x0, %al
callq 0xbef0
jmp 0xcaeb
jmp 0xca16
leaq 0x1010(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0xc7c0
cmpl $0x1, %eax
jne 0xca37
jmp 0xcacb
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0xc7c0
cmpl $0x400, 0x20c0a93(%rip) # imm = 0x400
jge 0xcab6
leaq 0x1010(%rsp), %rdi
callq 0x46b0
movq %rax, %rcx
movslq 0x20c0a7a(%rip), %rdx   # 0x20cd4e8
leaq 0x20c0a7b(%rip), %rax   # 0x20cd4f0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x46b0
movq %rax, %rcx
movslq 0x20c0a55(%rip), %rdx   # 0x20cd4e8
leaq 0x20c0a56(%rip), %rax   # 0x20cd4f0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x20c0a3d(%rip), %eax   # 0x20cd4e8
addl $0x1, %eax
movl %eax, 0x20c0a34(%rip)   # 0x20cd4e8
jmp 0xcac6
leaq 0x1f33a(%rip), %rdi     # 0x2bdf7
movb $0x0, %al
callq 0xbef0
jmp 0xcacb
jmp 0xca16
movq 0x8(%rsp), %rdi
callq 0x43a0
leaq 0x2010(%rsp), %rsi
leaq 0x1f337(%rip), %rdi     # 0x2be1b
movb $0x0, %al
callq 0xb5d0
addq $0x3028, %rsp           # imm = 0x3028
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: FreeSlave[P]vhlt/common/scriplib.cpp
// Function: LoadScriptFile(char const*)
void            LoadScriptFile(const char* const filename)
{
    s_script = s_scriptstack;
    AddScriptToStack(filename);

    s_endofscript = false;
    s_tokenready = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
leaq 0x20c59e4(%rip), %rax   # 0x20d2520
movq %rax, 0x20c59c5(%rip)   # 0x20d2508
movq (%rsp), %rdi
callq 0xcb60
movb $0x0, 0x20c59c1(%rip)   # 0x20d2514
movb $0x0, 0x20c59bb(%rip)   # 0x20d2515
popq %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/scriplib.cpp
// Function: AddScriptToStack(char const*)
static void     AddScriptToStack(const char* const filename)
{
    int             size;

    s_script++;

    if (s_script == &s_scriptstack[MAX_INCLUDES])
        Error("s_script file exceeded MAX_INCLUDES");

	strcpy_s(s_script->filename, filename);

    size = LoadFile(s_script->filename, (char**)&s_script->buffer);

    Log("Entering %s\n", s_script->filename);

    s_script->line = 1;
    s_script->script_p = s_script->buffer;
    s_script->end_p = s_script->buffer + size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x20c5998(%rip), %rax   # 0x20d2508
addq $0x1020, %rax           # imm = 0x1020
movq %rax, 0x20c598b(%rip)   # 0x20d2508
leaq 0x20c599c(%rip), %rax   # 0x20d2520
addq $0x8100, %rax           # imm = 0x8100
cmpq %rax, 0x20c5977(%rip)   # 0x20d2508
jne 0xcba1
leaq 0x2051e(%rip), %rdi     # 0x2d0b8
movb $0x0, %al
callq 0xba80
movq 0x20c5960(%rip), %rdi   # 0x20d2508
movq 0x10(%rsp), %rsi
callq 0x4380
movq 0x20c594f(%rip), %rdi   # 0x20d2508
movq 0x20c5948(%rip), %rsi   # 0x20d2508
addq $0x1000, %rsi           # imm = 0x1000
callq 0xb180
movl %eax, 0xc(%rsp)
movq 0x20c5931(%rip), %rsi   # 0x20d2508
leaq 0x20587(%rip), %rdi     # 0x2d165
movb $0x0, %al
callq 0xb5d0
movq 0x20c591c(%rip), %rax   # 0x20d2508
movl $0x1, 0x1018(%rax)
movq 0x20c590b(%rip), %rax   # 0x20d2508
movq 0x1000(%rax), %rcx
movq 0x20c58fd(%rip), %rax   # 0x20d2508
movq %rcx, 0x1008(%rax)
movq 0x20c58ef(%rip), %rax   # 0x20d2508
movq 0x1000(%rax), %rcx
movslq 0xc(%rsp), %rax
addq %rax, %rcx
movq 0x20c58d9(%rip), %rax   # 0x20d2508
movq %rcx, 0x1010(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/scriplib.cpp
// Function: ParseFromMemory(char*, int)
void            ParseFromMemory(char* buffer, const int size)
{
    s_script = s_scriptstack;
    s_script++;

    if (s_script == &s_scriptstack[MAX_INCLUDES])
        Error("s_script file exceeded MAX_INCLUDES");

	strcpy_s(s_script->filename, "memory buffer");

    s_script->buffer = buffer;
    s_script->line = 1;
    s_script->script_p = s_script->buffer;
    s_script->end_p = s_script->buffer + size;

    s_endofscript = false;
    s_tokenready = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
leaq 0x20c58cc(%rip), %rax   # 0x20d2520
movq %rax, 0x20c58ad(%rip)   # 0x20d2508
movq 0x20c58a6(%rip), %rax   # 0x20d2508
addq $0x1020, %rax           # imm = 0x1020
movq %rax, 0x20c5899(%rip)   # 0x20d2508
leaq 0x20c58aa(%rip), %rax   # 0x20d2520
addq $0x8100, %rax           # imm = 0x8100
cmpq %rax, 0x20c5885(%rip)   # 0x20d2508
jne 0xcc93
leaq 0x2042c(%rip), %rdi     # 0x2d0b8
movb $0x0, %al
callq 0xba80
movq 0x20c586e(%rip), %rdi   # 0x20d2508
leaq 0x2043b(%rip), %rsi     # 0x2d0dc
callq 0x4380
movq 0x10(%rsp), %rcx
movq 0x20c5856(%rip), %rax   # 0x20d2508
movq %rcx, 0x1000(%rax)
movq 0x20c5848(%rip), %rax   # 0x20d2508
movl $0x1, 0x1018(%rax)
movq 0x20c5837(%rip), %rax   # 0x20d2508
movq 0x1000(%rax), %rcx
movq 0x20c5829(%rip), %rax   # 0x20d2508
movq %rcx, 0x1008(%rax)
movq 0x20c581b(%rip), %rax   # 0x20d2508
movq 0x1000(%rax), %rcx
movslq 0xc(%rsp), %rax
addq %rax, %rcx
movq 0x20c5805(%rip), %rax   # 0x20d2508
movq %rcx, 0x1010(%rax)
movb $0x0, 0x20c5803(%rip)   # 0x20d2514
movb $0x0, 0x20c57fd(%rip)   # 0x20d2515
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/scriplib.cpp
// Function: EndOfScript(bool)
bool            EndOfScript(const bool crossline)
{
    if (!crossline)
        Error("Line %i is incomplete (did you place a \" inside an entity string?) \n", s_scriptline);

    if (!strcmp(s_script->filename, "memory buffer"))
    {
        s_endofscript = true;
        return false;
    }

    free(s_script->buffer);

    if (s_script == s_scriptstack + 1)
    {
        s_endofscript = true;
        return false;
    }

    s_script--;
    s_scriptline = s_script->line;

    Log("returning to %s\n", s_script->filename);

    return GetToken(crossline);
}

// Assembly:
pushq %rax
movb %dil, %al
andb $0x1, %al
movb %al, 0x6(%rsp)
testb $0x1, 0x6(%rsp)
jne 0xcd55
movl 0x20c57c9(%rip), %esi   # 0x20d2510
leaq 0x2039c(%rip), %rdi     # 0x2d0ea
movb $0x0, %al
callq 0xba80
movq 0x20c57ac(%rip), %rdi   # 0x20d2508
leaq 0x20379(%rip), %rsi     # 0x2d0dc
callq 0x4530
cmpl $0x0, %eax
jne 0xcd7e
movb $0x1, 0x20c57a0(%rip)   # 0x20d2514
movb $0x0, 0x7(%rsp)
jmp 0xce05
movq 0x20c5783(%rip), %rax   # 0x20d2508
movq 0x1000(%rax), %rdi
callq 0x4470
leaq 0x20c5788(%rip), %rax   # 0x20d2520
addq $0x1020, %rax           # imm = 0x1020
cmpq %rax, 0x20c5763(%rip)   # 0x20d2508
jne 0xcdb5
movb $0x1, 0x20c5766(%rip)   # 0x20d2514
movb $0x0, 0x7(%rsp)
jmp 0xce05
movq 0x20c574c(%rip), %rax   # 0x20d2508
addq $-0x1020, %rax          # imm = 0xEFE0
movq %rax, 0x20c573f(%rip)   # 0x20d2508
movq 0x20c5738(%rip), %rax   # 0x20d2508
movl 0x1018(%rax), %eax
movl %eax, 0x20c5734(%rip)   # 0x20d2510
movq 0x20c5725(%rip), %rsi   # 0x20d2508
leaq 0x20345(%rip), %rdi     # 0x2d12f
movb $0x0, %al
callq 0xb5d0
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0xce10
andb $0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/scriplib.cpp
// Function: TokenAvailable()
bool            TokenAvailable()
{
    char           *search_p;

    search_p = s_script->script_p;

    if (search_p >= s_script->end_p)
        return false;

    while (*search_p <= 32)
    {
        if (*search_p == '\n')
            return false;

        search_p++;

        if (search_p == s_script->end_p)
            return false;
    }

    if (*search_p == ';')
        return false;

    return true;
}

// Assembly:
movq 0x20c51e1(%rip), %rax   # 0x20d2508
movq 0x1008(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x20c51c9(%rip), %rcx   # 0x20d2508
cmpq 0x1010(%rcx), %rax
jb 0xd34f
movb $0x0, -0x1(%rsp)
jmp 0xd3b7
jmp 0xd351
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jg 0xd39e
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xd372
movb $0x0, -0x1(%rsp)
jmp 0xd3b7
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x20c517c(%rip), %rcx   # 0x20d2508
cmpq 0x1010(%rcx), %rax
jne 0xd39c
movb $0x0, -0x1(%rsp)
jmp 0xd3b7
jmp 0xd351
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0xd3b2
movb $0x0, -0x1(%rsp)
jmp 0xd3b7
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: FreeSlave[P]vhlt/common/threads.cpp
// Function: ThreadSetPriority(q_threadpriority)
void            ThreadSetPriority(q_threadpriority type)
{
    int             val;

    g_threadpriority = type;

    // Currently in Linux land users are incapable of raising the priority level of their processes
    // Unless you are root -high is useless . . . 
    switch (g_threadpriority)
    {
    case eThreadPriorityLow:
        val = PRIO_MAX;
        break;

    case eThreadPriorityHigh:
        val = PRIO_MIN;
        break;

    case eThreadPriorityNormal:
    default:
        val = 0;
        break;
    }
    setpriority(PRIO_PROCESS, 0, val);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x20ccbce(%rip)   # 0x20da620
movl 0x20ccbc8(%rip), %eax   # 0x20da620
movl %eax, 0xc(%rsp)
subl $-0x1, %eax
je 0xda78
jmp 0xda63
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0xda8c
jmp 0xda6d
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xda82
jmp 0xda8e
movl $0x14, 0x10(%rsp)
jmp 0xda96
movl $0xffffffec, 0x10(%rsp) # imm = 0xFFFFFFEC
jmp 0xda96
jmp 0xda8e
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %edx
xorl %esi, %esi
movl %esi, %edi
callq 0x4130
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/threads.cpp
// Function: ThreadSetDefault()
void            ThreadSetDefault()
{
    if (g_numthreads == -1)
    {
        g_numthreads = PlatformThreadDefault();
        if (g_numthreads == -1) {
            g_numthreads = 1;
        }
    }
}

// Assembly:
pushq %rax
cmpl $-0x1, 0x2992c(%rip)    # 0x373e4
jne 0xdada
callq 0xdae0
movl %eax, 0x2991f(%rip)     # 0x373e4
cmpl $-0x1, 0x29918(%rip)    # 0x373e4
jne 0xdad8
movl $0x1, 0x2990c(%rip)     # 0x373e4
jmp 0xdada
popq %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/threads.cpp
// Function: PlatformThreadDefault()
static int PlatformThreadDefault()
{
#ifdef _GNU_SOURCE
    cpu_set_t cs;
    CPU_ZERO(&cs);
    if (sched_getaffinity(0, sizeof(cs), &cs) != 0) {
        return UnixThreadDefault();
    } else {
        int i;
        int count = 0;
        for (i = 0; i < CPU_COUNT(&cs); i++)
        {
            if (CPU_ISSET(i, &cs))
                count++;
        }
        return count;
    }
#else
    return UnixThreadDefault();
#endif
}

// Assembly:
subq $0xa8, %rsp
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x4210
xorl %edi, %edi
movl $0x80, %esi
leaq 0x20(%rsp), %rdx
callq 0x45c0
cmpl $0x0, %eax
je 0xdb1f
callq 0xdcb0
movl %eax, 0xa4(%rsp)
jmp 0xdbe5
movl $0x0, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x80, %edi
leaq 0x20(%rsp), %rsi
callq 0x40a0
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0xdbda
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0xdba6
movq 0x10(%rsp), %rax
shrq $0x6, %rax
movq 0x20(%rsp,%rax,8), %rax
movq 0x10(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
jmp 0xdbae
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0xdbae
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xdbc8
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdbca
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xdb2f
movl 0x18(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/threads.cpp
// Function: threads_InitCrit()
void            threads_InitCrit()
{
    pthread_mutexattr_t mattrib;

    if (!my_mutex)
    {
        my_mutex = (pthread_mutex_t*)Alloc(sizeof(*my_mutex));
        if (pthread_mutexattr_init(&mattrib) == -1)
        {
            Error("pthread_mutex_attr_init failed");
        }
        if (pthread_mutex_init(my_mutex, &mattrib) == -1)
        {
            Error("pthread_mutex_init failed");
        }
    }
}

// Assembly:
pushq %rax
cmpq $0x0, 0x20ccd6f(%rip)   # 0x20da978
jne 0xdc5f
movl $0x28, %edi
callq 0x4aa0
movq %rax, 0x20ccd5c(%rip)   # 0x20da978
leaq 0x4(%rsp), %rdi
callq 0x4070
cmpl $-0x1, %eax
jne 0xdc39
leaq 0x1f792(%rip), %rdi     # 0x2d3c4
movb $0x0, %al
callq 0xba80
movq 0x20ccd38(%rip), %rdi   # 0x20da978
leaq 0x4(%rsp), %rsi
callq 0x45a0
cmpl $-0x1, %eax
jne 0xdc5d
leaq 0x1f78d(%rip), %rdi     # 0x2d3e3
movb $0x0, %al
callq 0xba80
jmp 0xdc5f
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/threads.cpp
// Function: UnixThreadDefault()
static int UnixThreadDefault()
{
    long sysconfResult = sysconf(_SC_NPROCESSORS_ONLN);
    if (sysconfResult) {
        return (int)sysconfResult;
    }
    return -1;
}

// Assembly:
subq $0x18, %rsp
movl $0x54, %edi
callq 0x4260
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdcd6
movq 0x8(%rsp), %rax
movl %eax, 0x14(%rsp)
jmp 0xdcde
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getPlane(double (&) [3], double&) const
void            Winding::getPlane(vec3_t& normal, vec_t& dist) const
{
    vec3_t          v1, v2;

    //hlassert(m_NumPoints >= 3);

    if (m_NumPoints >= 3)
    {
        VectorSubtract(m_Points[1], m_Points[0], v1);
        VectorSubtract(m_Points[2], m_Points[0], v2);
        CrossProduct(v2, v1, normal);
        VectorNormalize(normal);
        dist = DotProduct(m_Points[0], normal);
    }
    else
    {
        VectorClear(normal);
        dist = 0.0;
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x3, 0x8(%rax)
jb 0xe1bd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movsd 0x18(%rcx), %xmm0
movq 0x10(%rax), %rcx
subsd (%rcx), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x10(%rax), %rcx
movsd 0x20(%rcx), %xmm0
movq 0x10(%rax), %rcx
subsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x10(%rax), %rcx
movsd 0x28(%rcx), %xmm0
movq 0x10(%rax), %rcx
subsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x10(%rax), %rcx
movsd 0x30(%rcx), %xmm0
movq 0x10(%rax), %rcx
subsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%rax), %rcx
movsd 0x38(%rcx), %xmm0
movq 0x10(%rax), %rcx
subsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rcx
movsd 0x40(%rcx), %xmm0
movq 0x10(%rax), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x40(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd 0x38(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x20(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd 0x40(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd 0x38(%rsp), %xmm2
movsd 0x18(%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
movq 0x58(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x58(%rsp), %rdi
callq 0x121b0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movsd (%rcx), %xmm1
movq 0x58(%rsp), %rcx
movsd (%rcx), %xmm2
movq 0x10(%rax), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x58(%rsp), %rcx
mulsd 0x8(%rcx), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x10(%rax), %rax
movsd 0x10(%rax), %xmm0
movq 0x58(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x50(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0xe1ef
movq 0x58(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x58(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x58(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getBounds(double (&) [3], double (&) [3]) const
void            Winding::getBounds(vec3_t& mins, vec3_t& maxs) const
{
    BoundingBox     bounds;
    unsigned    x;

    for (x=0; x<m_NumPoints; x++)
    {
        bounds.add(m_Points[x]);
    }
    VectorCopy(bounds.m_Mins, mins);
    VectorCopy(bounds.m_Maxs, maxs);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x122c0
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0xe4d4
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rsi
leaq 0x20(%rsp), %rdi
callq 0x122d0
jmp 0xe4ab
jmp 0xe4ad
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xe47e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12480
jmp 0xe541
movsd 0x20(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x28(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x30(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd 0x38(%rsp), %xmm0
movq 0x50(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x40(%rsp), %xmm0
movq 0x50(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x48(%rsp), %xmm0
movq 0x50(%rsp), %rax
movsd %xmm0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
callq 0x12480
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x4650
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getBounds(BoundingBox&) const
void            Winding::getBounds(BoundingBox& bounds) const
{
    bounds.reset();
    unsigned    x;

    for (x=0; x<m_NumPoints; x++)
    {
        bounds.add(m_Points[x]);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x12490
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0xe5b3
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
movl 0x14(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x122d0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe57a
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getCenter(double (&) [3]) const
void            Winding::getCenter(vec3_t& center) const
{
    unsigned int    i;
    vec_t           scale;

    if (m_NumPoints > 0)
    {
        VectorCopy(vec3_origin, center);
        for (i = 0; i < m_NumPoints; i++)
        {
            VectorAdd(m_Points[i], center, center);
        }

        scale = 1.0 / m_NumPoints;
        VectorScale(center, scale, center);
    }
    else
    {
        VectorClear(center);
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpl $0x0, 0x8(%rax)
jbe 0xe72f
leaq 0x1d8ab(%rip), %rax     # 0x2be90
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x1d897(%rip), %rax     # 0x2be90
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
leaq 0x1d881(%rip), %rax     # 0x2be90
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movl $0x0, -0x14(%rsp)
movq -0x28(%rsp), %rcx
movl -0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0xe6c2
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rcx
movl -0x14(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm0
movq -0x10(%rsp), %rcx
addsd (%rcx), %xmm0
movq -0x10(%rsp), %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rcx
movl -0x14(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq -0x10(%rsp), %rcx
addsd 0x8(%rcx), %xmm0
movq -0x10(%rsp), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x10(%rax), %rax
movl -0x14(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
addsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xe626
movq -0x28(%rsp), %rax
movl 0x8(%rax), %eax
cvtsi2sd %rax, %xmm1
movsd 0x1eaa1(%rip), %xmm0    # 0x2d178
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
mulsd -0x20(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
mulsd -0x20(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
mulsd -0x20(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0xe755
movq -0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Valid() const
bool          Winding::Valid() const
{
    // TODO: Check to ensure there are 3 non-colinear points
    if ((m_NumPoints < 3) || (!m_Points))
    {
        return false;
    }
    return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x3, 0x8(%rax)
jb 0xed31
movq -0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xed38
movb $0x0, -0x1(%rsp)
jmp 0xed3d
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Winding(double (*) [3], unsigned int)
Winding::Winding(vec3_t *points, UINT32 numpoints)
{
	hlassert(numpoints >= 3);
	m_NumPoints = numpoints;
	m_MaxPoints = (m_NumPoints + 3) & ~3;	// groups of 4

	m_Points = new vec3_t[m_MaxPoints];
	memcpy(m_Points, points, sizeof(vec3_t) * m_NumPoints);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x26fdd(%rip), %rcx     # 0x35d80
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
callq 0x4310
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::initFromPoints(double (*) [3], unsigned int)
void			Winding::initFromPoints(vec3_t *points, UINT32 numpoints)
{
	hlassert(numpoints >= 3);

	Reset();

	m_NumPoints = numpoints;
	m_MaxPoints = (m_NumPoints + 3) & ~3;	// groups of 4

	m_Points = new vec3_t[m_MaxPoints];
	memcpy(m_Points, points, sizeof(vec3_t) * m_NumPoints);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xeea0
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
callq 0x4310
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Reset()
void			Winding::Reset(void)
{
	if(m_Points)
	{
		delete [] m_Points;
		m_Points = NULL;
	}

	m_NumPoints = m_MaxPoints = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rax)
je 0xeee3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xeed6
movq (%rsp), %rdi
callq 0x44f0
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::operator=(Winding const&)
Winding&      Winding::operator=(const Winding& other)
{
    delete[] m_Points;
    m_NumPoints = other.m_NumPoints;
    m_MaxPoints = (m_NumPoints + 3) & ~3;   // groups of 4

    m_Points = new vec3_t[m_MaxPoints];
    memcpy(m_Points, other.m_Points, sizeof(vec3_t) * m_NumPoints);
    return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xef31
movq 0x10(%rsp), %rdi
callq 0x44f0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
callq 0x4310
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Winding(unsigned int)
Winding::Winding(UINT32 numpoints)
{
    hlassert(numpoints >= 3);
    m_NumPoints = numpoints;
    m_MaxPoints = (m_NumPoints + 3) & ~3;   // groups of 4

    m_Points = new vec3_t[m_MaxPoints];
    memset(m_Points, 0, sizeof(vec3_t) * m_NumPoints);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x26dc3(%rip), %rcx     # 0x35d80
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
xorl %esi, %esi
callq 0x4210
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Winding(Winding const&)
Winding::Winding(const Winding& other)
{
    m_NumPoints = other.m_NumPoints;
    m_MaxPoints = (m_NumPoints + 3) & ~3;   // groups of 4

    m_Points = new vec3_t[m_MaxPoints];
    memcpy(m_Points, other.m_Points, sizeof(vec3_t) * m_NumPoints);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x26d42(%rip), %rcx     # 0x35d80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x3, %ecx
andl $-0x4, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
movl 0x8(%rax), %eax
imulq $0x18, %rax, %rdx
callq 0x4310
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Clip(dplane_t const&, Winding**, Winding**, double)
void            Winding::Clip(const dplane_t& plane, Winding** front, Winding** back
#ifdef ZHLT_WINDING_EPSILON
							  , vec_t epsilon
#endif
							  )
{
    vec3_t normal;
    vec_t dist;
    VectorCopy(plane.normal, normal);
    dist = plane.dist;
    Clip(normal, dist, front, back
#ifdef ZHLT_WINDING_EPSILON
		, epsilon
#endif
		);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movsd 0x30(%rsp), %xmm1
callq 0xfe00
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::Chop(double const*, double, double)
bool          Winding::Chop(const vec3_t normal, const vec_t dist
#ifdef ZHLT_WINDING_EPSILON
							, vec_t epsilon
#endif
							)
{
    Winding*      f;
    Winding*      b;

    Clip(normal, dist, &f, &b
#ifdef ZHLT_WINDING_EPSILON
		, epsilon
#endif
		);
    if (b)
    {
        delete b;
    }

    if (f)
    {
        delete[] m_Points;
        m_NumPoints = f->m_NumPoints;
        m_Points = f->m_Points;
        f->m_Points = NULL;
        delete f;
        return true;
    }
    else
    {
        m_NumPoints = 0;
        delete[] m_Points;
        m_Points = NULL;
        return false;
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x50(%rsp), %rsi
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
leaq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0xfe00
cmpq $0x0, 0x30(%rsp)
je 0x10969
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x10967
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x10969
cmpq $0x0, 0x38(%rsp)
je 0x109db
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1098f
movq 0x18(%rsp), %rdi
callq 0x44f0
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x109d4
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, 0x67(%rsp)
jmp 0x10a12
movq 0x28(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x10a00
movq 0x8(%rsp), %rdi
callq 0x44f0
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::WindingOnPlaneSide(double const*, double, double)
int             Winding::WindingOnPlaneSide(const vec3_t normal, const vec_t dist
#ifdef ZHLT_WINDING_EPSILON
											, vec_t epsilon
#endif
											)
{
    bool            front, back;
    unsigned int    i;
    vec_t           d;

    front = false;
    back = false;
    for (i = 0; i < m_NumPoints; i++)
    {
        d = DotProduct(m_Points[i], normal) - dist;
        if (d < -ON_EPSILON)
        {
            if (front)
            {
                return SIDE_CROSS;
            }
            back = true;
            continue;
        }
        if (d > ON_EPSILON)
        {
            if (back)
            {
                return SIDE_CROSS;
            }
            front = true;
            continue;
        }
    }

    if (back)
    {
        return SIDE_BACK;
    }
    if (front)
    {
        return SIDE_FRONT;
    }
    return SIDE_ON;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movsd %xmm0, -0x20(%rsp)
movsd %xmm1, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x40(%rsp)
movb $0x0, -0x29(%rsp)
movb $0x0, -0x2a(%rsp)
movl $0x0, -0x30(%rsp)
movq -0x40(%rsp), %rcx
movl -0x30(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x10b56
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rcx
movl -0x30(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd (%rcx), %xmm1
movq -0x18(%rsp), %rcx
movsd (%rcx), %xmm2
movq 0x10(%rax), %rcx
movl -0x30(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x8(%rcx), %xmm0
movq -0x18(%rsp), %rcx
mulsd 0x8(%rcx), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq 0x10(%rax), %rax
movl -0x30(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x38(%rsp), %xmm1
movsd -0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10b1e
testb $0x1, -0x29(%rsp)
je 0x10b17
movl $0xfffffffe, -0x4(%rsp) # imm = 0xFFFFFFFE
jmp 0x10b80
movb $0x1, -0x2a(%rsp)
jmp 0x10b46
movsd -0x38(%rsp), %xmm0
ucomisd -0x28(%rsp), %xmm0
jbe 0x10b44
testb $0x1, -0x2a(%rsp)
je 0x10b3d
movl $0xfffffffe, -0x4(%rsp) # imm = 0xFFFFFFFE
jmp 0x10b80
movb $0x1, -0x29(%rsp)
jmp 0x10b46
jmp 0x10b46
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x10a52
testb $0x1, -0x2a(%rsp)
je 0x10b67
movl $0x1, -0x4(%rsp)
jmp 0x10b80
testb $0x1, -0x29(%rsp)
je 0x10b78
movl $0x0, -0x4(%rsp)
jmp 0x10b80
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)