LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Log(char const*, ...)
void CDECL FORMAT_PRINTF(1,2)      Log(const char* const warning, ...)
{
    char            message[MAX_MESSAGE];

    va_list         argptr;

    va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
    vsnprintf(message, MAX_MESSAGE, Localize (warning), argptr);
#else
    vsnprintf(message, MAX_MESSAGE, warning, argptr);
#endif
    va_end(argptr);

    WriteLog(message);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x9ed4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rbx
movq %r10, 0x10(%rbx)
leaq 0x8f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x9fc2
leaq 0xd0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
movq %r14, %rdi
callq 0xa0db
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: LogError(char const*)
void            LogError(const char* const message)
{
    if (g_log && CompileLog)
    {
        char            logfilename[_MAX_PATH];
        FILE*           ErrorLog = NULL;

        safe_snprintf(logfilename, _MAX_PATH, "%s.err", g_Mapname);
        ErrorLog = fopen(logfilename, "a");

        if (ErrorLog)
        {
            fprintf(ErrorLog, "%s: %s\n", g_Program, message);
            fflush(ErrorLog);
            fclose(ErrorLog);
            ErrorLog = NULL;
        }
        else
        {
#ifdef ZHLT_LANGFILE
            fprintf(stderr, Localize ("ERROR: Could not open error logfile %s"), logfilename);
#else
            fprintf(stderr, "ERROR: Could not open error logfile %s", logfilename);
#endif
            fflush(stderr);
#ifdef ZHLT_CONSOLE
			if (twice)
			{
#ifdef ZHLT_LANGFILE
				fprintf (conout, Localize ("ERROR: Could not open error logfile %s"), logfilename);
#else
				fprintf (conout, "ERROR: Could not open error logfile %s", logfilename);
#endif
				fflush (conout);
			}
#endif
        }
    }
}

// Assembly:
cmpb $0x1, 0x1f422(%rip)     # 0x29350
jne 0x9fb7
cmpq $0x0, 0x20b9554(%rip)   # 0x20c3490
je 0x9fb7
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
leaq 0x13b4b(%rip), %rdx     # 0x1da9d
leaq 0x1e3f7(%rip), %rcx     # 0x28350
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x8a47
leaq 0x153eb(%rip), %rsi     # 0x1f35d
movq %r14, %rdi
callq 0x4380
testq %rax, %rax
je 0x9fb8
movq %rax, %r14
movq 0x1e3b7(%rip), %rdx     # 0x28340
leaq 0x13b67(%rip), %rsi     # 0x1daf7
movq %rax, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4460
movq %r14, %rdi
callq 0x4370
movq %r14, %rdi
callq 0x42f0
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movq %rsp, %rdi
callq 0x4640
jmp 0x9fad
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Localize(char const*)
const char * Localize (const char *s)
{
	int i;
	for (i=0; i<g_lang_count; i++)
	{
		if (!strcmp (g_lang[i][0], s))
		{
			return g_lang[i][1];
		}
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x20b54b4(%rip), %r14   # 0x20bf488
testq %r14, %r14
jle 0xa007
shlq $0x4, %r14
xorl %r15d, %r15d
leaq 0x20b54a9(%rip), %r12   # 0x20bf490
movq (%r15,%r12), %rdi
movq %rbx, %rsi
callq 0x4440
testl %eax, %eax
je 0xa002
addq $0x10, %r15
cmpq %r15, %r14
jne 0x9fe7
jmp 0xa007
movq 0x8(%r15,%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: CloseLog()
void CDECL      CloseLog()
{
    if (g_log && CompileLog)
    {
        LogEnd();
        fflush(CompileLog);
        fclose(CompileLog);
        CompileLog = NULL;
    }
}

// Assembly:
cmpb $0x1, 0x1f2d4(%rip)     # 0x29350
jne 0xa0c5
cmpq $0x0, 0x20b940a(%rip)   # 0x20c3490
je 0xa0c5
pushq %rax
movq 0x1e2b0(%rip), %rsi     # 0x28340
leaq 0x13bf7(%rip), %rdi     # 0x1dc8e
xorl %eax, %eax
callq 0x9e76
movq 0x20b93eb(%rip), %rdi   # 0x20c3490
callq 0x4370
movq 0x20b93df(%rip), %rdi   # 0x20c3490
callq 0x42f0
movq $0x0, 0x20b93cf(%rip) # 0x20c3490
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: WriteLog(char const*)
void            WriteLog(const char* const message)
{

#ifndef SYSTEM_WIN32
    if (CompileLog)
    {
        fprintf(CompileLog, "%s", message); //fprintf(CompileLog, message); //--vluzacn
        fflush(CompileLog);
    }
#else
    Safe_WriteLog(message);
#endif

    fprintf(stdout, "%s", message); //fprintf(stdout, message); //--vluzacn
    fflush(stdout);
#ifdef ZHLT_CONSOLE
	if (twice)
	{
		fprintf (conout, "%s", message);
		fflush (conout);
	}
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20b93a7(%rip), %rsi   # 0x20c3490
testq %rsi, %rsi
je 0xa102
movq %rbx, %rdi
callq 0x4360
movq 0x20b9393(%rip), %rdi   # 0x20c3490
callq 0x4370
movq 0x1de87(%rip), %r14     # 0x27f90
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4360
movq (%r14), %rdi
callq 0x4370
cmpb $0x1, 0x20b5355(%rip)   # 0x20bf478
jne 0xa147
movq 0x20b5354(%rip), %rsi   # 0x20bf480
movq %rbx, %rdi
callq 0x4360
movq 0x20b5345(%rip), %rdi   # 0x20bf480
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4370
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Error(char const*, ...)
void CDECL FORMAT_PRINTF(1,2)      Error(const char* const error, ...)
{
    char            message[MAX_ERROR];
    char            message2[MAX_ERROR];
    va_list         argptr;
    
 /*#if defined( SYSTEM_WIN32 ) && !defined( __MINGW32__ ) && !defined( __BORLANDC__ )
    {
        char* wantint3 = getenv("WANTINT3");
		if (wantint3)
		{
			if (atoi(wantint3))
			{
				__asm
				{
					int 3;
				}
			}
		}
    }
#endif*/

    va_start(argptr, error);
#ifdef ZHLT_LANGFILE
    vsnprintf(message, MAX_ERROR, Localize (error), argptr);
#else
    vsnprintf(message, MAX_ERROR, error, argptr);
#endif
    va_end(argptr);

#ifdef ZHLT_LANGFILE
    safe_snprintf(message2, MAX_MESSAGE, "%s%s\n", Localize ("Error: "), message);
#else
    safe_snprintf(message2, MAX_MESSAGE, "Error: %s\n", message);
#endif
    WriteLog(message2);
    LogError(message2);

    fatal = 1;
    CheckFatal();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x10d8, %rsp           # imm = 0x10D8
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xa1c2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rbx
movq %r10, 0x10(%rbx)
leaq 0x10f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x9fc2
leaq 0x8d0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
leaq 0x1393e(%rip), %rdi     # 0x1db47
callq 0x9fc2
leaq 0x13942(%rip), %rdx     # 0x1db57
leaq 0xd0(%rsp), %rbx
movl $0x800, %esi            # imm = 0x800
movq %rbx, %rdi
movq %rax, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x8a47
movq %rbx, %rdi
callq 0xa0db
movq %rbx, %rdi
callq 0x9f27
movb $0x1, 0x20b924f(%rip)   # 0x20c3498
movl $0x1, %edi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Fatal(assume_msgs, char const*, ...)
void CDECL FORMAT_PRINTF(2,3)      Fatal(assume_msgs msgid, const char* const warning, ...)
{
    char            message[MAX_WARNING];
    char            message2[MAX_WARNING];

    va_list         argptr;

    va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
    vsnprintf(message, MAX_WARNING, Localize (warning), argptr);
#else
    vsnprintf(message, MAX_WARNING, warning, argptr);
#endif
    va_end(argptr);

#ifdef ZHLT_LANGFILE
    safe_snprintf(message2, MAX_MESSAGE, "%s%s\n", Localize ("Error: "), message);
#else
    safe_snprintf(message2, MAX_MESSAGE, "Error: %s\n", message);
#endif
    WriteLog(message2);
    LogError(message2);

    {
        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
        PrintOnce(message);
    }

    fatal = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18d0, %rsp           # imm = 0x18D0
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xa2b5
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x1900(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq %rsi, %rdi
callq 0x9fc2
leaq 0x10d0(%rsp), %r15
movl $0x800, %esi            # imm = 0x800
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x41e0
leaq 0x13848(%rip), %rdi     # 0x1db47
callq 0x9fc2
leaq 0x1384c(%rip), %rdx     # 0x1db57
leaq 0x8d0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x8a47
movq %r14, %rdi
callq 0xa0db
movq %r14, %rdi
callq 0x9f27
movl %ebx, %edi
callq 0xadb0
movq %rax, %r14
movq (%rax), %rdi
callq 0x9fc2
movq %rax, %rbx
leaq 0x13809(%rip), %rdi     # 0x1db5d
callq 0x9fc2
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x9fc2
movq %rax, %r12
leaq 0x137fc(%rip), %rdi     # 0x1db6b
callq 0x9fc2
movq %rax, %r13
movq 0x10(%r14), %rdi
callq 0x9fc2
movq %rax, %r10
leaq 0x137c5(%rip), %rdx     # 0x1db4f
leaq 0xd0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rbx, %rcx
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r13
callq 0x8a47
addq $0x10, %rsp
movq %r14, %rdi
xorl %eax, %eax
callq 0xa3d4
movb $0x1, 0x20b90d5(%rip)   # 0x20c3498
addq $0x18d0, %rsp           # imm = 0x18D0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: PrintOnce(char const*, ...)
void CDECL FORMAT_PRINTF(1,2)      PrintOnce(const char* const warning, ...)
{
    char            message[MAX_WARNING];
    char            message2[MAX_WARNING];
    va_list         argptr;
    static int      count = 0;

    if (count > 0) // make sure it only gets called once
    {
        return;
    }
    count++;

    va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
    vsnprintf(message, MAX_WARNING, Localize (warning), argptr);
#else
    vsnprintf(message, MAX_WARNING, warning, argptr);
#endif
    va_end(argptr);

#ifdef ZHLT_LANGFILE
    safe_snprintf(message2, MAX_MESSAGE, "%s%s\n", Localize ("Error: "), message);
#else
    safe_snprintf(message2, MAX_MESSAGE, "Error: %s\n", message);
#endif
    WriteLog(message2);
    LogError(message2);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x10d8, %rsp           # imm = 0x10D8
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xa432
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpb $0x0, 0x20b9063(%rip)   # 0x20c349c
jne 0xa4cb
movb $0x1, 0x20b9056(%rip)   # 0x20c349c
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0x10f0(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
callq 0x9fc2
leaq 0x8d0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
leaq 0x136b5(%rip), %rdi     # 0x1db47
callq 0x9fc2
leaq 0x136b9(%rip), %rdx     # 0x1db57
leaq 0xd0(%rsp), %rbx
movl $0x800, %esi            # imm = 0x800
movq %rbx, %rdi
movq %rax, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x8a47
movq %rbx, %rdi
callq 0xa0db
movq %rbx, %rdi
callq 0x9f27
addq $0x10d8, %rsp           # imm = 0x10D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Warning(char const*, ...)
void CDECL FORMAT_PRINTF(1,2)      Warning(const char* const warning, ...)
{
    char            message[MAX_WARNING];
    char            message2[MAX_WARNING];

    va_list         argptr;

    va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
    vsnprintf(message, MAX_WARNING, Localize (warning), argptr);
#else
    vsnprintf(message, MAX_WARNING, warning, argptr);
#endif
    va_end(argptr);

#ifdef ZHLT_LANGFILE
    safe_snprintf(message2, MAX_MESSAGE, "%s%s\n", Localize ("Warning: "), message);
#else
    safe_snprintf(message2, MAX_MESSAGE, "Warning: %s\n", message);
#endif
    WriteLog(message2);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x10d8, %rsp           # imm = 0x10D8
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xa534
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rbx
movq %r10, 0x10(%rbx)
leaq 0x10f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x9fc2
leaq 0x8d0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
leaq 0x135fc(%rip), %rdi     # 0x1db77
callq 0x9fc2
leaq 0x135d0(%rip), %rdx     # 0x1db57
leaq 0xd0(%rsp), %rbx
movl $0x800, %esi            # imm = 0x800
movq %rbx, %rdi
movq %rax, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x8a47
movq %rbx, %rdi
callq 0xa0db
addq $0x10d8, %rsp           # imm = 0x10D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Verbose(char const*, ...)
void CDECL FORMAT_PRINTF(1,2)      Verbose(const char* const warning, ...)
{
    if (g_verbose)
    {
        char            message[MAX_MESSAGE];

        va_list         argptr;

        va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
        vsnprintf(message, MAX_MESSAGE, Localize (warning), argptr);
#else
        vsnprintf(message, MAX_MESSAGE, warning, argptr);
#endif
        va_end(argptr);

        WriteLog(message);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
testb %al, %al
je 0xa5fc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
cmpb $0x1, 0x20b4e48(%rip)   # 0x20bf464
jne 0xa66b
leaq 0x20(%rsp), %rax
movq %rsp, %rbx
movq %rax, 0x10(%rbx)
leaq 0x8f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x9fc2
leaq 0xd0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
movq %r14, %rdi
callq 0xa0db
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: Developer(developer_level_t, char const*, ...)
void CDECL FORMAT_PRINTF(2,3)      Developer(developer_level_t level, const char* const warning, ...)
{
    if (level <= g_developer)
    {
        char            message[MAX_MESSAGE];

        va_list         argptr;

        va_start(argptr, warning);
#ifdef ZHLT_LANGFILE
        vsnprintf(message, MAX_MESSAGE, Localize (warning), argptr);
#else
        vsnprintf(message, MAX_MESSAGE, warning, argptr);
#endif
        va_end(argptr);

        WriteLog(message);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
testb %al, %al
je 0xa6bb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
cmpl %edi, 0x20b4d8b(%rip)   # 0x20bf460
jl 0xa727
leaq 0x20(%rsp), %rax
movq %rsp, %rbx
movq %rax, 0x10(%rbx)
leaq 0x8f0(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rbx)
movq %rsi, %rdi
callq 0x9fc2
leaq 0xd0(%rsp), %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x41e0
movq %r14, %rdi
callq 0xa0db
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/log.cpp
// Function: LogStart(int, char**)
void            LogStart(int argc, char** argv)
{
    Banner();
    Log("-----  BEGIN  %s -----\n", g_Program);
    LogArgs(argc, argv);
    DisplayDeveloperLevel();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
movl %edi, %ebp
movq 0x1dbc5(%rip), %rsi     # 0x28340
leaq 0x133ff(%rip), %rdi     # 0x1db81
leaq 0x13411(%rip), %rdx     # 0x1db9a
xorl %eax, %eax
callq 0x9e76
leaq 0x1340f(%rip), %rdi     # 0x1dba6
xorl %eax, %eax
callq 0x9e76
movq 0x1db9b(%rip), %rsi     # 0x28340
leaq 0x134ca(%rip), %rdi     # 0x1dc76
xorl %eax, %eax
callq 0x9e76
leaq 0x135ea(%rip), %rdi     # 0x1dda4
xorl %eax, %eax
callq 0x9e76
testl %ebp, %ebp
jle 0xa805
movl %ebp, %r15d
leaq 0x135ea(%rip), %r12     # 0x1ddb9
leaq 0x135dd(%rip), %r13     # 0x1ddb3
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %r14
movq %r14, %rdi
movl $0x20, %esi
callq 0x4150
testq %rax, %rax
movq %r13, %rdi
cmoveq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x9e76
incq %rbp
cmpq %rbp, %r15
jne 0xa7d8
leaq 0x1349c(%rip), %rdi     # 0x1dca8
xorl %eax, %eax
callq 0x9e76
leaq 0x135a3(%rip), %rsi     # 0x1ddbd
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8ae9
movl 0x20b4c33(%rip), %eax   # 0x20bf460
cmpl $0x6, %eax
jl 0xa84c
leaq 0x135a3(%rip), %rsi     # 0x1dddc
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4c14(%rip), %eax   # 0x20bf460
cmpl $0x5, %eax
jl 0xa86b
leaq 0x13588(%rip), %rsi     # 0x1dde0
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4bf5(%rip), %eax   # 0x20bf460
cmpl $0x4, %eax
jl 0xa88a
leaq 0x1356f(%rip), %rsi     # 0x1dde6
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4bd6(%rip), %eax   # 0x20bf460
cmpl $0x3, %eax
jl 0xa8a9
leaq 0x13557(%rip), %rsi     # 0x1dded
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4bb7(%rip), %eax   # 0x20bf460
cmpl $0x2, %eax
jl 0xa8c8
leaq 0x13541(%rip), %rsi     # 0x1ddf6
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4b98(%rip), %eax   # 0x20bf460
testl %eax, %eax
jle 0xa8e6
leaq 0x144a1(%rip), %rsi     # 0x1ed74
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x8b00
movl 0x20b4b7a(%rip), %eax   # 0x20bf460
testl %eax, %eax
je 0xa90b
leaq 0x16db8(%rip), %rsi     # 0x216a9
movq %rsp, %rbx
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
callq 0x8b00
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9e76
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edi, %edi
je 0xa922
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movl %esi, %edi
callq 0xadb0
movq %rax, %r14
movq (%rax), %rdi
callq 0x9fc2
movq %rax, %rbx
leaq 0x1320f(%rip), %rdi     # 0x1db5d
callq 0x9fc2
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x9fc2
movq %rax, %r12
leaq 0x13202(%rip), %rdi     # 0x1db6b
callq 0x9fc2
movq %rax, %r13
movq 0x10(%r14), %rdi
callq 0x9fc2
movq %rax, %r10
leaq 0x131cb(%rip), %rdx     # 0x1db4f
movq %rsp, %r14
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %rbx, %rcx
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r13
callq 0x8a47
addq $0x10, %rsp
movq %r14, %rdi
xorl %eax, %eax
callq 0xa164
// File: /workspace/github_cpp_makefile_star2_O3/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:
cvttss2si %xmm0, %rsi
movl %esi, %eax
movl $0x88888889, %ecx       # imm = 0x88888889
imulq %rax, %rcx
shrq $0x25, %rcx
imull $0x3c, %ecx, %edx
movl %esi, %r8d
subl %edx, %r8d
imulq $0x8888889, %rcx, %rdx  # imm = 0x8888889
shrq $0x21, %rdx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl $0x91a2b3c5, %edx       # imm = 0x91A2B3C5
imulq %rax, %rdx
shrq $0x2b, %rdx
imulq $0xaaaaaab, %rdx, %rdi  # imm = 0xAAAAAAB
shrq $0x20, %rdi
shll $0x3, %edi
leal (%rdi,%rdi,2), %edi
subl %edi, %edx
cmpl $0x15180, %esi          # imm = 0x15180
jae 0xaa23
cvtss2sd %xmm0, %xmm0
testl %edx, %edx
je 0xaa42
leaq 0x132bd(%rip), %rdi     # 0x1dcd2
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
movb $0x1, %al
jmp 0x9e76
movl $0xc22e4507, %esi       # imm = 0xC22E4507
imulq %rax, %rsi
shrq $0x30, %rsi
cvtss2sd %xmm0, %xmm0
leaq 0x1326f(%rip), %rdi     # 0x1dcaa
movb $0x1, %al
jmp 0x9e76
testl %ecx, %ecx
je 0xaa59
leaq 0x132a9(%rip), %rdi     # 0x1dcf6
movl %ecx, %esi
movl %r8d, %edx
movb $0x1, %al
jmp 0x9e76
leaq 0x132b6(%rip), %rdi     # 0x1dd16
movb $0x1, %al
jmp 0x9e76
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xaad6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0x8e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rdi
movl $0x800, %esi            # imm = 0x800
movq %r10, %rdx
callq 0x41e0
cmpb $0x1, 0x20b4967(%rip)   # 0x20bf479
jne 0xab36
movq 0x20b4965(%rip), %rsi   # 0x20bf480
leaq 0xd0(%rsp), %rdi
callq 0x4360
movq 0x20b4951(%rip), %rdi   # 0x20bf480
callq 0x4370
jmp 0xab4d
movq 0x1d453(%rip), %rax     # 0x27f90
movq (%rax), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x4360
addq $0x8d8, %rsp            # imm = 0x8D8
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
decl %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x4500
cmpl $0xd, %eax
je 0xab70
movl %eax, %r15d
cmpl $-0x1, %eax
je 0xac41
cmpl $0xa, %r15d
je 0xac41
cmpl $0x5c, %r15d
jne 0xaba4
testb $0x1, %r13b
movb $0x1, %r13b
je 0xab70
jmp 0xabeb
testb $0x1, %r13b
je 0xac1f
cmpl $0x65, %r15d
jg 0xabca
cmpl $0x5c, %r15d
je 0xabeb
cmpl $0x61, %r15d
je 0xabf3
cmpl $0x62, %r15d
jne 0xac1f
movl $0x8, %r15d
jmp 0xac1f
leal -0x6e(%r15), %eax
cmpl $0x8, %eax
ja 0xabfb
leaq 0x12e06(%rip), %rcx     # 0x1d9e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, %r15d
jmp 0xac1f
movl $0x5c, %r15d
jmp 0xac1f
movl $0x7, %r15d
jmp 0xac1f
cmpl $0x66, %r15d
jne 0xac1f
movl $0xc, %r15d
jmp 0xac1f
movl $0xb, %r15d
jmp 0xac1f
movl $0xd, %r15d
jmp 0xac1f
movl $0x9, %r15d
cmpl %ebp, %r12d
jge 0xac33
movl %r12d, %eax
incl %r12d
movb %r15b, (%rbx,%rax)
jmp 0xab6d
leaq 0x130f2(%rip), %rdi     # 0x1dd2c
xorl %eax, %eax
callq 0xa4d6
movl %r12d, %eax
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
cmpl $-0x1, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3008, %rsp           # imm = 0x3008
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0x143cc(%rip), %rsi     # 0x1f058
movq %rbx, %rdi
callq 0x4380
testq %rax, %rax
jne 0xacca
movq %rsp, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x874d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4570
leaq 0x1439f(%rip), %rsi     # 0x1f058
movq %rbx, %rdi
callq 0x4380
testq %rax, %rax
je 0xad9b
movq %rax, %rbx
leaq 0x1000(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
callq 0xab55
testl %eax, %eax
jne 0xad70
leaq 0x2000(%rsp), %r14
leaq 0x1000(%rsp), %r15
leaq 0x20b478f(%rip), %r12   # 0x20bf490
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0xab55
movslq 0x20b4770(%rip), %r13   # 0x20bf488
cmpq $0x3ff, %r13            # imm = 0x3FF
jg 0xad62
movq %r15, %rdi
callq 0x45a0
movq %r13, %rbp
shlq $0x4, %rbp
movq %rax, (%rbp,%r12)
movq %r14, %rdi
callq 0x45a0
movq %rax, 0x8(%rbp,%r12)
leal 0x1(%r13), %eax
movl %eax, 0x20b473c(%rip)   # 0x20bf488
movq %r15, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0xab55
testl %eax, %eax
je 0xad01
jmp 0xad70
leaq 0x12ffe(%rip), %rdi     # 0x1dd67
xorl %eax, %eax
callq 0xa4d6
movq %rbx, %rdi
callq 0x42f0
leaq 0x1300c(%rip), %rdi     # 0x1dd8b
movq %rsp, %rsi
xorl %eax, %eax
callq 0x9e76
addq $0x3008, %rsp           # imm = 0x3008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12fad(%rip), %rdi     # 0x1dd4f
movq %r14, %rsi
xorl %eax, %eax
callq 0xa4d6
jmp 0xad89
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x20b96ec(%rip), %rax   # 0x20c44c0
movq %rax, 0x20b96cd(%rip)   # 0x20c44a8
callq 0xadf0
xorl %eax, %eax
movb %al, 0x20b96cc(%rip)    # 0x20c44b4
movb %al, 0x20b96c7(%rip)    # 0x20c44b5
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movl $0x1020, %eax           # imm = 0x1020
addq 0x20b96ab(%rip), %rax   # 0x20c44a8
movq %rdi, %rbx
movq %rax, 0x20b96a1(%rip)   # 0x20c44a8
leaq 0x20c17b2(%rip), %rcx   # 0x20cc5c0
cmpq %rcx, %rax
jne 0xae28
leaq 0x1420e(%rip), %rdi     # 0x1f028
xorl %eax, %eax
callq 0xa164
movq 0x20b9680(%rip), %rax   # 0x20c44a8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
movq 0x20b966e(%rip), %rdi   # 0x20c44a8
leaq 0x1000(%rdi), %rsi
callq 0x9aac
movl %eax, %ebx
movq 0x20b9659(%rip), %rsi   # 0x20c44a8
leaq 0x1427f(%rip), %rdi     # 0x1f0d5
xorl %eax, %eax
callq 0x9e76
movq 0x20b9644(%rip), %rax   # 0x20c44a8
movl $0x1, 0x1018(%rax)
movq 0x1000(%rax), %rcx
movq %rcx, 0x1008(%rax)
movslq %ebx, %rdx
addq %rcx, %rdx
movq %rdx, 0x1010(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jne 0xaf15
movl 0x20b95a9(%rip), %esi   # 0x20c44b0
leaq 0x1414c(%rip), %rdi     # 0x1f05a
xorl %eax, %eax
callq 0xa164
movq 0x20b958c(%rip), %r14   # 0x20c44a8
leaq 0x14129(%rip), %rsi     # 0x1f04c
movq %r14, %rdi
callq 0x4440
testl %eax, %eax
je 0xaf82
movq 0x1000(%r14), %rdi
callq 0x4390
movq 0x20b9566(%rip), %rax   # 0x20c44a8
leaq 0x20ba597(%rip), %rcx   # 0x20c54e0
cmpq %rcx, %rax
je 0xaf82
leaq -0x1020(%rax), %rsi
movq %rsi, 0x20b954c(%rip)   # 0x20c44a8
movl -0x8(%rax), %eax
movl %eax, 0x20b954b(%rip)   # 0x20c44b0
leaq 0x14133(%rip), %rdi     # 0x1f09f
xorl %eax, %eax
callq 0x9e76
movzbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaf93
movb $0x1, 0x20b952b(%rip)   # 0x20c44b4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $-0x1, 0x1dbc8(%rip)    # 0x29354
je 0xb78f
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movl $0x80, %esi
xorl %edi, %edi
callq 0x44d0
testl %eax, %eax
je 0xb7e4
movl $0x54, %edi
callq 0x41f0
movq %rax, %rbx
testq %rax, %rax
jne 0xb830
jmp 0xb835
movq %rsp, %rsi
movl $0x80, %edi
callq 0x40a0
testl %eax, %eax
jle 0xb83c
xorl %r15d, %r15d
movq %rsp, %r14
xorl %ebx, %ebx
cmpq $0x3ff, %r15            # imm = 0x3FF
ja 0xb819
movq %r15, %rax
shrq $0x6, %rax
movq (%rsp,%rax,8), %rax
btq %r15, %rax
jae 0xb819
incl %ebx
incq %r15
movl $0x80, %edi
movq %r14, %rsi
callq 0x40a0
cltq
cmpq %rax, %r15
jl 0xb7fd
cmpl $-0x1, %ebx
jne 0xb83e
movl $0x1, %ebx
jmp 0xb83e
xorl %ebx, %ebx
movl %ebx, 0x1db10(%rip)     # 0x29354
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpq $0x0, 0x20c10bf(%rip)   # 0x20cc918
je 0xb85c
retq
pushq %rax
movl $0x28, %edi
callq 0x4974
movq %rax, 0x20c10aa(%rip)   # 0x20cc918
leaq 0x4(%rsp), %rdi
callq 0x4070
cmpl $-0x1, %eax
jne 0xb88b
leaq 0x13944(%rip), %rdi     # 0x1f1c8
xorl %eax, %eax
callq 0xa164
movq 0x20c1086(%rip), %rdi   # 0x20cc918
leaq 0x4(%rsp), %rsi
callq 0x44b0
cmpl $-0x1, %eax
jne 0xb8af
leaq 0x1393f(%rip), %rdi     # 0x1f1e7
xorl %eax, %eax
callq 0xa164
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getPlane(dplane_t&) const
void     Winding::getPlane(dplane_t& plane) const
{
    vec3_t          v1, v2;
    vec3_t          plane_normal;

    //hlassert(m_NumPoints >= 3);

    if (m_NumPoints >= 3)
    {
        VectorSubtract(m_Points[2], m_Points[1], v1);
        VectorSubtract(m_Points[0], m_Points[1], v2);

        CrossProduct(v2, v1, plane_normal);
        VectorNormalize(plane_normal);
        VectorCopy(plane_normal, plane.normal);               // change from vec_t
        plane.dist = DotProduct(m_Points[0], plane.normal);
    }
    else
    {
        VectorClear(plane.normal);
        plane.dist = 0.0;
    }
}

// Assembly:
cmpl $0x3, 0x8(%rdi)
jb 0xba66
movq 0x10(%rdi), %rax
movsd 0x18(%rax), %xmm1
movsd 0x38(%rax), %xmm2
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movupd 0x20(%rax), %xmm3
subsd %xmm3, %xmm2
movsd 0x40(%rax), %xmm4
movhpd 0x30(%rax), %xmm4       # xmm4 = xmm4[0],mem[0]
movupd 0x8(%rax), %xmm5
subpd %xmm3, %xmm5
shufpd $0x1, %xmm1, %xmm3      # xmm3 = xmm3[1],xmm1[0]
subpd %xmm3, %xmm4
movapd %xmm5, %xmm1
shufpd $0x1, %xmm0, %xmm1      # xmm1 = xmm1[1],xmm0[0]
mulsd %xmm2, %xmm0
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm1, %xmm2
movapd %xmm5, %xmm1
mulpd %xmm4, %xmm1
subpd %xmm2, %xmm1
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulsd %xmm5, %xmm4
subsd %xmm4, %xmm0
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
movsd 0x10739(%rip), %xmm2    # 0x1c118
xorl %eax, %eax
ucomisd %xmm3, %xmm2
seta %cl
movapd %xmm3, %xmm2
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
divpd %xmm2, %xmm1
xorpd %xmm2, %xmm2
ja 0xba02
divsd %xmm3, %xmm0
movapd %xmm0, %xmm2
movb %cl, %al
movd %eax, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pslld $0x1f, %xmm0
psrad $0x1f, %xmm0
cvtpd2ps %xmm1, %xmm1
pandn %xmm1, %xmm0
movq %xmm0, (%rsi)
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0x8(%rsi)
movq 0x10(%rdi), %rax
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x8(%rax), %xmm0
mulsd (%rax), %xmm2
cvtss2sd %xmm1, %xmm1
mulsd 0x10(%rax), %xmm1
addsd %xmm0, %xmm2
addsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
jmp 0xba77
movl $0x0, 0x8(%rsi)
movq $0x0, (%rsi)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x3, 0x8(%rdi)
jb 0xbb89
movq 0x10(%rdi), %rax
movsd (%rax), %xmm1
movsd 0x20(%rax), %xmm2
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movupd 0x8(%rax), %xmm3
subsd %xmm3, %xmm2
movsd 0x28(%rax), %xmm4
movhpd 0x18(%rax), %xmm4       # xmm4 = xmm4[0],mem[0]
movupd 0x38(%rax), %xmm5
subpd %xmm3, %xmm5
shufpd $0x1, %xmm1, %xmm3      # xmm3 = xmm3[1],xmm1[0]
subpd %xmm3, %xmm4
movapd %xmm5, %xmm1
shufpd $0x1, %xmm0, %xmm1      # xmm1 = xmm1[1],xmm0[0]
mulsd %xmm2, %xmm0
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm1, %xmm2
movapd %xmm5, %xmm1
mulpd %xmm4, %xmm1
subpd %xmm2, %xmm1
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulsd %xmm5, %xmm4
subsd %xmm4, %xmm0
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
movsd 0x105f5(%rip), %xmm2    # 0x1c118
xorl %eax, %eax
ucomisd %xmm3, %xmm2
seta %cl
movapd %xmm3, %xmm2
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
divpd %xmm2, %xmm1
xorpd %xmm2, %xmm2
ja 0xbb46
divsd %xmm3, %xmm0
movapd %xmm0, %xmm2
movb %cl, %al
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pslld $0x1f, %xmm0
psrad $0x1f, %xmm0
pandn %xmm1, %xmm0
movsd %xmm2, 0x10(%rsi)
movdqu %xmm0, (%rsi)
movq 0x10(%rdi), %rax
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
mulsd 0x8(%rax), %xmm1
mulsd (%rax), %xmm0
addsd %xmm1, %xmm0
mulsd 0x10(%rax), %xmm2
addsd %xmm0, %xmm2
jmp 0xbb9d
xorpd %xmm0, %xmm0
movupd %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
xorpd %xmm2, %xmm2
movsd %xmm2, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/common/winding.cpp
// Function: Winding::getArea() const
vec_t           Winding::getArea() const
{
    unsigned int    i;
    vec3_t          d1, d2, cross;
    vec_t           total;

    //hlassert(m_NumPoints >= 3);

    total = 0.0;
    if (m_NumPoints >= 3)
    {
        for (i = 2; i < m_NumPoints; i++)
        {
            VectorSubtract(m_Points[i - 1], m_Points[0], d1);
            VectorSubtract(m_Points[i], m_Points[0], d2);
            CrossProduct(d1, d2, cross);
            total += 0.5 * VectorLength(cross);
        }
    }
    return total;
}

// Assembly:
movl 0x8(%rdi), %ecx
xorpd %xmm0, %xmm0
cmpq $0x3, %rcx
jb 0xbc9f
movq 0x10(%rdi), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd 0x10(%rax), %xmm3
movsd 0x18(%rax), %xmm7
movsd 0x20(%rax), %xmm6
movsd 0x28(%rax), %xmm5
leaq (%rcx,%rcx,2), %rcx
leaq -0x30(,%rcx,8), %rcx
xorl %edx, %edx
movsd 0x13696(%rip), %xmm4    # 0x1f280
subsd %xmm1, %xmm7
subsd %xmm2, %xmm6
subsd %xmm3, %xmm5
movsd 0x30(%rax,%rdx), %xmm12
movsd 0x38(%rax,%rdx), %xmm8
movapd %xmm8, %xmm10
subsd %xmm2, %xmm10
movsd 0x40(%rax,%rdx), %xmm9
movapd %xmm9, %xmm13
subsd %xmm3, %xmm13
movapd %xmm10, %xmm14
movapd %xmm6, %xmm11
mulsd %xmm13, %xmm11
mulsd %xmm7, %xmm13
mulsd %xmm7, %xmm10
movapd %xmm12, %xmm7
subsd %xmm1, %xmm12
mulsd %xmm5, %xmm14
subsd %xmm14, %xmm11
mulsd %xmm12, %xmm5
subsd %xmm13, %xmm5
mulsd %xmm6, %xmm12
subsd %xmm12, %xmm10
mulsd %xmm5, %xmm5
mulsd %xmm11, %xmm11
addsd %xmm5, %xmm11
mulsd %xmm10, %xmm10
addsd %xmm11, %xmm10
xorps %xmm5, %xmm5
sqrtsd %xmm10, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm5, %xmm0
addq $0x18, %rdx
movapd %xmm9, %xmm5
movapd %xmm8, %xmm6
cmpq %rdx, %rcx
jne 0xbbea
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0xbcfc
movq 0x10(%rdi), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
movapd 0x135f4(%rip), %xmm0    # 0x1f2b0
movapd 0x135fc(%rip), %xmm2    # 0x1f2c0
movsd 0x135c4(%rip), %xmm1    # 0x1f290
movsd 0x135b4(%rip), %xmm3    # 0x1f288
xorl %edi, %edi
movupd (%rax,%rdi), %xmm4
minpd %xmm4, %xmm2
maxpd %xmm4, %xmm0
movsd 0x10(%rax,%rdi), %xmm4
minsd %xmm4, %xmm3
maxsd %xmm4, %xmm1
addq $0x18, %rdi
cmpq %rdi, %rcx
jne 0xbcd6
jmp 0xbd1c
movapd 0x135ac(%rip), %xmm0    # 0x1f2b0
movapd 0x135b4(%rip), %xmm2    # 0x1f2c0
movsd 0x13574(%rip), %xmm3    # 0x1f288
movsd 0x13574(%rip), %xmm1    # 0x1f290
movupd %xmm2, (%rsi)
movsd %xmm3, 0x10(%rsi)
movupd %xmm0, (%rdx)
movsd %xmm1, 0x10(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x8(%rdi)
je 0xbe0c
leaq 0x1205d(%rip), %rax     # 0x1de00
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm0
movsd %xmm2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movsd 0x10(%rax), %xmm1
movsd %xmm1, 0x10(%rsi)
cmpl $0x0, 0x8(%rdi)
je 0xbe1b
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
addsd (%rdx,%rax), %xmm2
movsd %xmm2, (%rsi)
movq 0x10(%rdi), %rdx
addsd 0x8(%rdx,%rax), %xmm0
movsd %xmm0, 0x8(%rsi)
movq 0x10(%rdi), %rdx
addsd 0x10(%rdx,%rax), %xmm1
movsd %xmm1, 0x10(%rsi)
incq %rcx
movl 0x8(%rdi), %edx
addq $0x18, %rax
cmpq %rdx, %rcx
jb 0xbdc9
movl %edx, %eax
cvtsi2sd %rax, %xmm3
jmp 0xbe1f
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
retq
xorpd %xmm3, %xmm3
movsd 0x132c1(%rip), %xmm4    # 0x1f0e8
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm2
movsd %xmm2, (%rsi)
mulsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsi)
mulsd %xmm1, %xmm4
movsd %xmm4, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc354
callq 0x4410
movq $0x0, 0x10(%r15)
movl %r14d, 0x8(%r15)
leal 0x3(%r14), %eax
andl $-0x4, %eax
movl %eax, 0x18(%r15)
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x4040
movq %rax, 0x10(%r15)
movl %r14d, %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc3aa
callq 0x4410
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
movl %eax, 0x18(%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc3cd
callq 0x4410
movl 0x8(%r14), %r15d
movl %r15d, 0x8(%rbx)
leal 0x3(%r15), %eax
andl $-0x4, %eax
movl %eax, 0x18(%rbx)
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x4040
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rsi
shlq $0x3, %r15
leaq (%r15,%r15,2), %rdx
movq %rax, %rdi
callq 0x4260
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop