LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/util.c
// Function: debugPoke
int debugPoke( char *fileName, int *valueOut )
{
    int errCode = 1;
    FILE *fpr;
    static char tmpBuf[256];

    if ( NULL != (fpr = fopen( fileName, "rt" )) ) {
        if ( NULL != fgets( tmpBuf, 256, fpr ) ) {
            if ( 1 == sscanf( tmpBuf, "%d", valueOut )) {
                errCode = 0;
            }
        }
        fclose( fpr );
    }
    return( errCode ); 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0xc2e1(%rip), %rsi      # 0x1be8b
callq 0x8320
testq %rax, %rax
je 0xfbf3
movq %rax, %rbx
leaq 0xb8de2(%rip), %rdi     # 0xc89a0
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x8200
testq %rax, %rax
je 0xfbfa
leaq 0xb8dc9(%rip), %rdi     # 0xc89a0
leaq 0xc4e7(%rip), %rsi      # 0x1c0c5
movq %r14, %rdx
xorl %eax, %eax
callq 0x82d0
xorl %ebp, %ebp
cmpl $0x1, %eax
setne %bpl
jmp 0xfbff
movl $0x1, %ebp
jmp 0xfc07
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x8100
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmCreate
alarmObj *alarmCreate( int (*alarmCBfunc)( char * ) )
{
    alarmObj *aPtr = NULL;
    int i;

    aPtr = calloc( 1, sizeof( alarmObj ));
    if ( aPtr != NULL ) {
        aPtr->alarmTime = 0L;
        aPtr->alarmCallbackFunction = alarmCBfunc;

        for (i = 0; i<SISSM_MAXALARMS; i++) {
            if ( alarmTable[ i ] == NULL ) {
                alarmTable[ i ] = aPtr;
                aPtr->usedIndex = i;
                break;
            }
        }
    }
    return aPtr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x8210
testq %rax, %rax
je 0xfc66
movq %rbx, 0x8(%rax)
leaq 0xb8e5a(%rip), %rdx     # 0xc8aa0
xorl %ecx, %ecx
cmpq $0x0, (%rdx)
je 0xfc60
incq %rcx
addq $0x8, %rdx
cmpq $0x80, %rcx
jne 0xfc48
jmp 0xfc66
movq %rax, (%rdx)
movl %ecx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmDestroy
int alarmDestroy( alarmObj *aPtr )
{
    int errCode = 1;
    if ( NULL != aPtr ) {
        if ( aPtr->usedIndex != -1 ) {
            alarmTable[ aPtr->usedIndex ] = NULL;
            free( aPtr );
            errCode = 0;
        }
    }
    return errCode;
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
je 0xfc97
movslq 0x10(%rdi), %rcx
cmpq $-0x1, %rcx
je 0xfc97
pushq %rax
leaq 0xb8e1c(%rip), %rax     # 0xc8aa0
movq $0x0, (%rax,%rcx,8)
callq 0x8040
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmDispatch
void alarmDispatch( void )
{
    alarmObj *aPtr;
    unsigned long timeNow;
    int i;
 
    timeNow = (unsigned long) time(NULL);

    for (i = 0; i<SISSM_MAXALARMS; i++) {
        aPtr = alarmTable[ i ];
        if ( aPtr != NULL ) {
            if ( aPtr->alarmTime != 0L ) {
                if ( aPtr->alarmTime <= timeNow ) {
                    aPtr->alarmTime = 0L;
                    if ( aPtr->alarmCallbackFunction != NULL ) {
                        (aPtr->alarmCallbackFunction)("alarm");
                    }
                }
            }
        }
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x82a0
movq %rax, %rbx
leaq 0xb8d9b(%rip), %r12     # 0xc8aa0
leaq 0x10898(%rip), %r14     # 0x205a4
movq (%r15,%r12), %rax
testq %rax, %rax
je 0xfd35
movq (%rax), %rcx
decq %rcx
cmpq %rbx, %rcx
jae 0xfd35
movq $0x0, (%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfd35
movq %r14, %rdi
callq *%rax
addq $0x8, %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0xfd0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/pioverride.c
// Function: pokeCvar
static void _pokeCvar( void )
{
    int i;
    char cvarStr[256], cvarVal[256];
    char *w1, *w2;

    for (i=0; i<10; i++) {

        w1 = getWord( pioverrideConfig.cvar[i], 0, " " );
        w2 = getWord( pioverrideConfig.cvar[i], 1, " " );

	if (( w1 != NULL ) && ( w2 != NULL )) {
            strlcpy( cvarStr, w1, 256);
            strlcpy( cvarVal, w2, 256);

	    if ( (0 != strlen(cvarStr)) && (0 != strlen(cvarVal)) ) {
                apiGameModePropertySet( cvarStr, cvarVal );
	        logPrintf( LOG_LEVEL_INFO, "pioverride", "Setting ::%s:: to ::%s::", cvarStr, cvarVal );
	    }
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl $0x4, %r13d
leaq 0xc1e4(%rip), %rbx      # 0x1c14e
leaq 0x100(%rsp), %r14
movq %rsp, %r15
leaq 0xb8f24(%rip), %rax     # 0xc8ea0
leaq (%rax,%r13), %rbp
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xf82d
movq %rax, %r12
movq %rbp, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xf82d
movq %rax, %rbp
testq %r12, %r12
setne %al
testq %rbp, %rbp
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x10011
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %r12, %rsi
callq 0xf384
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf384
cmpb $0x0, 0x100(%rsp)
je 0x10011
cmpb $0x0, (%rsp)
je 0x10011
movq %r14, %rdi
movq %r15, %rsi
callq 0x131ed
movl $0x2, %edi
leaq 0xd720(%rip), %rsi      # 0x1d71d
leaq 0xd724(%rip), %rdx      # 0x1d728
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1a3e3
addq $0x400, %r13            # imm = 0x400
cmpq $0x2804, %r13           # imm = 0x2804
jne 0xff75
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/pioverride.c
// Function: pioverrideInstallPlugin
int pioverrideInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pioverrideInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( pioverrideConfig.pluginState == 0 ) return 0;

    // Install Event-driven CallBack hooks so the plugin gets
    // notified for various happenings.  A complete list is here,
    // but comment out what is not needed for your plug-in.
    // 
    eventsRegister( SISSM_EV_CLIENT_ADD,           pioverrideClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           pioverrideClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 pioverrideInitCB );
    eventsRegister( SISSM_EV_RESTART,              pioverrideRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            pioverrideMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           pioverrideGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             pioverrideGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          pioverrideRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            pioverrideRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   pioverrideCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             pioverridePeriodicCB );
    return 0;
}

// Assembly:
pushq %rax
callq 0xfd50
cmpl $0x0, 0xb8e3a(%rip)     # 0xc8ea0
je 0x10127
leaq -0x140(%rip), %rsi      # 0xff33
movl $0x3, %edi
callq 0xd40c
leaq -0x14e(%rip), %rsi      # 0xff36
movl $0x4, %edi
callq 0xd40c
leaq -0x15c(%rip), %rsi      # 0xff39
movl $0x1, %edi
callq 0xd40c
leaq -0x16a(%rip), %rsi      # 0xff3c
movl $0x2, %edi
callq 0xd40c
leaq -0x178(%rip), %rsi      # 0xff3f
movl $0x5, %edi
callq 0xd40c
leaq -0x186(%rip), %rsi      # 0xff42
movl $0x6, %edi
callq 0xd40c
leaq -0xa2(%rip), %rsi       # 0x10037
movl $0x7, %edi
callq 0xd40c
leaq -0xb0(%rip), %rsi       # 0x1003a
movl $0x8, %edi
callq 0xd40c
leaq -0xab(%rip), %rsi       # 0x10050
movl $0x9, %edi
callq 0xd40c
leaq -0xb9(%rip), %rsi       # 0x10053
movl $0xa, %edi
callq 0xd40c
leaq -0xc7(%rip), %rsi       # 0x10056
movl $0xb, %edi
callq 0xd40c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: pisoloplayerInitConfig
int pisoloplayerInitConfig( void )
{
    cfsPtr cP;

    cP = cfsCreate( sissmGetConfigPath() );

    // read "pisoloplayer.pluginstate" variable from the .cfg file
    pisoloplayerConfig.pluginState = (int) cfsFetchNum( cP, "pisoloplayer.pluginState", 0.0 );  // disabled by default

    // how players constitute "solo"?  Typically '1' but you may override to higher player count
    //
    pisoloplayerConfig.soloPlayerThreshold = (int) cfsFetchNum( cP, "pisoloplayer.soloPlayerThreshold", 1.0 ); 

    strlcpy( pisoloplayerConfig.soloWarning, 
        cfsFetchStr( cP, "pisoloplayer.soloWarning", "Counterattack disabled for a single player" ), CFS_FETCH_MAX);
    strlcpy( pisoloplayerConfig.multiWarning, 
        cfsFetchStr( cP, "pisoloplayer.multiWarning", "Counterattack enabled for multi-players" ), CFS_FETCH_MAX);
    strlcpy( pisoloplayerConfig.defendTimer, 
        cfsFetchStr( cP, "pisoloplayer.defendTimer", "90" ), CFS_FETCH_MAX);

    cfsDestroy( cP );
    return 0;
}

// Assembly:
pushq %rbx
callq 0x8970
movq %rax, %rdi
callq 0x8ffc
movq %rax, %rbx
leaq 0xd5fd(%rip), %rsi      # 0x1d741
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0xbb54e(%rip)     # 0xcb6a8
leaq 0xd5f9(%rip), %rsi      # 0x1d75a
movsd 0xaebf(%rip), %xmm0     # 0x1b028
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0xbb531(%rip)     # 0xcb6ac
leaq 0xd5f9(%rip), %rsi      # 0x1d77b
leaq 0xd60b(%rip), %rdx      # 0x1d794
movq %rbx, %rdi
callq 0x9073
leaq 0xbb918(%rip), %rdi     # 0xcbab0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0xd613(%rip), %rsi      # 0x1d7bf
leaq 0xd626(%rip), %rdx      # 0x1d7d9
movq %rbx, %rdi
callq 0x9073
leaq 0xbb4ee(%rip), %rdi     # 0xcb6b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0xd62b(%rip), %rsi      # 0x1d801
leaq 0xd63d(%rip), %rdx      # 0x1d81a
movq %rbx, %rdi
callq 0x9073
leaq 0xbbcc4(%rip), %rdi     # 0xcbeb0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
movq %rbx, %rdi
callq 0x9054
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: singlePlayerNoCounter
static int _singlePlayerNoCounter( void )
{
    char *w;

    w = apiGetServerMode();
    if ((0==strcmp( w, "checkpoint" )) || (0==strcmp( w, "hardcore")) )  {
        if ( pisoloplayerConfig.soloPlayerThreshold >= apiPlayersGetCount() ) {
            apiGameModePropertySet( "DefendTimer", "3");
	    apiSay( pisoloplayerConfig.soloWarning );
            logPrintf( LOG_LEVEL_INFO, "pisoloplayer", "Counterattack disabled for a single player" );
        }
        else {
            apiGameModePropertySet( "DefendTimer", pisoloplayerConfig.defendTimer);  // default "90"
	    apiSay( pisoloplayerConfig.multiWarning );
            logPrintf( LOG_LEVEL_INFO, "pisoloplayer", "Counterattack enabled for multi-players" );
        }
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x13dc1
movq %rax, %rbx
leaq 0xcd91(%rip), %rsi      # 0x1cfb3
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x10249
leaq 0xbdc2(%rip), %rsi      # 0x1bff7
movq %rbx, %rdi
callq 0x8220
testl %eax, %eax
je 0x10249
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0xbb45d(%rip), %ebx     # 0xcb6ac
callq 0x13853
cmpl %eax, %ebx
leaq 0xbbc53(%rip), %rax     # 0xcbeb0
leaq 0xf75e(%rip), %rsi      # 0x1f9c2
cmovlq %rax, %rsi
leaq 0xbb441(%rip), %rax     # 0xcb6b0
leaq 0xbb83a(%rip), %rbx     # 0xcbab0
cmovlq %rax, %rbx
leaq 0xd558(%rip), %rax      # 0x1d7d9
leaq 0xd50c(%rip), %r14      # 0x1d794
cmovlq %rax, %r14
leaq 0xd58a(%rip), %rdi      # 0x1d81d
callq 0x131ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13337
leaq 0xd580(%rip), %rsi      # 0x1d829
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a3e3
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: pisoloplayerInstallPlugin
int pisoloplayerInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pisoloplayerInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( pisoloplayerConfig.pluginState == 0 ) return 0;

    // Install Event-driven CallBack hooks so the plugin gets
    // notified for various happenings.  A complete list is here,
    // but comment out what is not needed for your plug-in.
    // 
    eventsRegister( SISSM_EV_CLIENT_ADD,           pisoloplayerClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           pisoloplayerClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 pisoloplayerInitCB );
    eventsRegister( SISSM_EV_RESTART,              pisoloplayerRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            pisoloplayerMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           pisoloplayerGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             pisoloplayerGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          pisoloplayerRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            pisoloplayerRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   pisoloplayerCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             pisoloplayerPeriodicCB );

    return 0;
}

// Assembly:
pushq %rax
callq 0x1012c
cmpl $0x0, 0xbb3a2(%rip)     # 0xcb6a8
je 0x103c7
leaq -0x10e(%rip), %rsi      # 0x10205
movl $0x3, %edi
callq 0xd40c
leaq -0x65(%rip), %rsi       # 0x102bf
movl $0x4, %edi
callq 0xd40c
leaq -0x6c(%rip), %rsi       # 0x102c9
movl $0x1, %edi
callq 0xd40c
leaq -0x7a(%rip), %rsi       # 0x102cc
movl $0x2, %edi
callq 0xd40c
leaq -0x88(%rip), %rsi       # 0x102cf
movl $0x5, %edi
callq 0xd40c
leaq -0x8f(%rip), %rsi       # 0x102d9
movl $0x6, %edi
callq 0xd40c
leaq -0x96(%rip), %rsi       # 0x102e3
movl $0x7, %edi
callq 0xd40c
leaq -0xa4(%rip), %rsi       # 0x102e6
movl $0x8, %edi
callq 0xd40c
leaq -0xab(%rip), %rsi       # 0x102f0
movl $0x9, %edi
callq 0xd40c
leaq -0xb9(%rip), %rsi       # 0x102f3
movl $0xa, %edi
callq 0xd40c
leaq -0xc7(%rip), %rsi       # 0x102f6
movl $0xb, %edi
callq 0xd40c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: convertNameToHyperlink
char *_convertNameToHyperlink( char *identString )
{
    static char retStr[256];
    char playerID[80], playerName[64], *q;
    int nameIndex, formatOfID = 0;

    //    internal test injection
    //    strlcpy( identString, "fe6c0000000000000000000000000001|20000000000000000000000000000003 111.001.034.025 Random Person", 256 );
    //    strlcpy( identString,  "0123456789012345 111.001.034.025 Random Person", 256 );

    // Get the first word of identString and check if Steam or EPIC
    //
    if ( NULL != (q = getWord( identString, 0, " " ))) {
        strlcpy( playerID, q, 80 );
        formatOfID = rosterIsValidGUID( playerID );
    }

    switch( formatOfID ) {
    case 1: // Steam
        nameIndex = 34;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_STEAM, playerID, playerName );
        break;
    case 2: // EPIC
        nameIndex = 82;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_EPIC, playerID, playerName );
        break;
    case 3: // WinGDK
        nameIndex = 33;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_WINGDK, playerID, playerName );
        break;
    default:
        strlcpy( retStr, "*InternalError*", 256 );
        break;
    }

    return( retStr );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0xbadf(%rip), %rdx      # 0x1c14e
xorl %esi, %esi
callq 0xf82d
testq %rax, %rax
je 0x106ce
movq %rsp, %r14
movl $0x50, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xf384
movq %r14, %rdi
callq 0x14378
cmpl $0x3, %eax
je 0x10707
cmpl $0x2, %eax
je 0x106de
cmpl $0x1, %eax
jne 0x106ce
addq $0x22, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf384
leaq 0xbcaab(%rip), %rdi     # 0xcd170
leaq 0xd317(%rip), %rdx      # 0x1d9e3
jmp 0x1072e
movups 0xd3d6(%rip), %xmm0     # 0x1daab
movaps %xmm0, 0xbca94(%rip)    # 0xcd170
jmp 0x10740
addq $0x52, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf384
leaq 0xbca72(%rip), %rdi     # 0xcd170
leaq 0xd326(%rip), %rdx      # 0x1da2b
jmp 0x1072e
addq $0x21, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf384
leaq 0xbca49(%rip), %rdi     # 0xcd170
leaq 0xd33d(%rip), %rdx      # 0x1da6b
movq %rsp, %rcx
movl $0x100, %esi            # imm = 0x100
movq %r14, %r8
xorl %eax, %eax
callq 0x8190
leaq 0xbca29(%rip), %rax     # 0xcd170
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: htmlSafeFilter
char *_htmlSafeFilter( char *strIn )
{
    int i;
    static char strOut[ PIWEBGEN_MAXROSTER ];

    strlcpy( strOut, strIn, PIWEBGEN_MAXROSTER );

    // replace metatag or escape-sequence characters
    // with something benign (antihack)
    //
    for (i=0; i< (int) strlen( strOut ); i++) {
        switch (strOut[i]) {
            case '<':   strOut[i] = '[';  break;
            case '>':   strOut[i] = ']';  break;
            case '/':   case '\\':  strOut[i] = '|';  break;
        }
    }

    // If utf-8 encoding is NOT declared, then assume ascii.
    // replace any non-printable encodings wtih asterisks.
    // 
    if ( 0 == piwebgenConfig.utf8Encoding ) {
        for (i=0; i< (int) strlen( strOut ); i++) {
            if ( strOut[i] != '\011' )  {
                if (!isprint( (int) strOut[i] )) strOut[i] = '*';
            }
        }
    }

    return( strOut );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0xbcb0f(%rip), %rbx     # 0xcd270
movl $0x4000, %edx           # imm = 0x4000
movq %rbx, %rdi
callq 0xf384
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x107bb
xorl %r14d, %r14d
movzbl (%r14,%rbx), %eax
cmpl $0x3d, %eax
jg 0x10795
cmpl $0x2f, %eax
je 0x107a3
movb $0x5b, %cl
cmpl $0x3c, %eax
je 0x107a5
jmp 0x107a9
cmpl $0x5c, %eax
je 0x107a3
cmpl $0x3e, %eax
jne 0x107a9
movb $0x5d, %cl
jmp 0x107a5
movb $0x7c, %cl
movb %cl, (%r14,%rbx)
incq %r14
movq %rbx, %rdi
callq 0x8120
cltq
cmpq %rax, %r14
jl 0x1077d
cmpl $0x0, 0xbbaf2(%rip)     # 0xcc2b4
jne 0x1080c
leaq 0xbcaa5(%rip), %rbx     # 0xcd270
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x1080c
xorl %r14d, %r14d
movsbq (%r14,%rbx), %r15
cmpq $0x9, %r15
je 0x107fa
callq 0x83e0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r15,2)
jne 0x107fa
movb $0x2a, (%r14,%rbx)
incq %r14
movq %rbx, %rdi
callq 0x8120
cltq
cmpq %rax, %r14
jl 0x107da
leaq 0xbca5d(%rip), %rax     # 0xcd270
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: piwebgenSigtermCB
int piwebgenSigtermCB( char *strIn )
{
    FILE *fpw;

    if (NULL != (fpw = fopen( piwebgenConfig.webFileName, "wt" ))) {

	if ( 0 != piwebgenConfig.autoRefreshHeader ) 
            fprintf( fpw, "<meta http-equiv=\"refresh\" content=\"14\" /> \n" );

        fprintf( fpw, "<br><br>SISSM shut down at: &nbsp; %s\n", apiTimeGetHuman(0L) );
        fclose( fpw );
    }

    return 0;
}

// Assembly:
pushq %rbx
leaq 0xbb430(%rip), %rdi     # 0xcc2b8
leaq 0xcc35(%rip), %rsi      # 0x1dac4
callq 0x8320
testq %rax, %rax
je 0x10ee1
movq %rax, %rbx
cmpl $0x0, 0xbc0a1(%rip)     # 0xccf44
je 0x10ebe
leaq 0xcc1b(%rip), %rdi      # 0x1dac7
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x8390
xorl %edi, %edi
callq 0x13156
leaq 0xcc28(%rip), %rsi      # 0x1daf4
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8250
movq %rbx, %rdi
callq 0x8100
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: piwebgenInstallPlugin
int piwebgenInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    piwebgenInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( piwebgenConfig.pluginState == 0 ) return 0;

    // Install Event-driven CallBack hooks so the plugin gets
    // notified for various happenings.  A complete list is here,
    // but comment out what is not needed for your plug-in.
    // 
    eventsRegister( SISSM_EV_CLIENT_ADD,           piwebgenClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           piwebgenClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 piwebgenInitCB );
    eventsRegister( SISSM_EV_RESTART,              piwebgenRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            piwebgenMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           piwebgenGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             piwebgenGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          piwebgenRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            piwebgenRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   piwebgenCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             piwebgenPeriodicCB );
    eventsRegister( SISSM_EV_SIGTERM,              piwebgenSigtermCB );

    return 0;
}

// Assembly:
pushq %rax
callq 0x103cc
cmpl $0x0, 0xbb3be(%rip)     # 0xcc2b0
je 0x10fc4
leaq -0x6e6(%rip), %rsi      # 0x10819
movl $0x3, %edi
callq 0xd40c
leaq -0x239(%rip), %rsi      # 0x10cd7
movl $0x4, %edi
callq 0xd40c
leaq -0x234(%rip), %rsi      # 0x10ced
movl $0x1, %edi
callq 0xd40c
leaq -0x22f(%rip), %rsi      # 0x10d03
movl $0x2, %edi
callq 0xd40c
leaq -0x23d(%rip), %rsi      # 0x10d06
movl $0x5, %edi
callq 0xd40c
leaq -0x238(%rip), %rsi      # 0x10d1c
movl $0x6, %edi
callq 0xd40c
leaq -0x239(%rip), %rsi      # 0x10d2c
movl $0x7, %edi
callq 0xd40c
leaq -0x247(%rip), %rsi      # 0x10d2f
movl $0x8, %edi
callq 0xd40c
leaq -0x255(%rip), %rsi      # 0x10d32
movl $0x9, %edi
callq 0xd40c
leaq -0x263(%rip), %rsi      # 0x10d35
movl $0xa, %edi
callq 0xd40c
leaq -0x271(%rip), %rsi      # 0x10d38
movl $0xb, %edi
callq 0xd40c
leaq -0x13a(%rip), %rsi      # 0x10e80
movl $0xf, %edi
callq 0xd40c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiRemoveCodes
void apiRemoveCodes( char *apiSayString )
{
    int j = 0;
    char *w;
    char removeWord[ API_LINE_STRING_MAX ];

    if ( 0 != strlen( removeCodes ) ) {
        while ( 1 == 1 ) {
            w = getWord( removeCodes, j++, " " );
            if ( w == NULL ) break;
            if ( 0 == strlen( w ) ) break;
            strlcpy( removeWord, w, API_LINE_STRING_MAX );
            strRemoveInPlace( apiSayString, removeWord );
        };
    };
    return;
}

// Assembly:
cmpb $0x0, 0xc02b1(%rip)     # 0xd1280
je 0x11065
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0xc0290(%rip), %rdi     # 0xd1280
leaq 0xb157(%rip), %rdx      # 0x1c14e
xorl %esi, %esi
callq 0xf82d
testq %rax, %rax
je 0x11054
movl $0x1, %r13d
movq %rsp, %r14
leaq 0xc026d(%rip), %r15     # 0xd1280
leaq 0xb134(%rip), %r12      # 0x1c14e
cmpb $0x0, (%rax)
je 0x11054
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %rax, %rsi
callq 0xf384
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf9cc
leal 0x1(%r13), %ebp
movq %r15, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0xf82d
movl %ebp, %r13d
testq %rax, %rax
jne 0x1101a
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiWordListRead
int apiWordListRead( char *listFile, wordList_t wordList )
{
    int i;
    char tmpLine[1024];
    FILE *fpr;

    for (i=0; i<WORDLISTMAXELEM; i++) strclr( wordList[i] );

    i = -1;
    if (NULL != (fpr = fopen( listFile, "rt" ))) {
        i = 0;
        while (!feof( fpr )) { 
            if (NULL != fgets( tmpLine, 1024, fpr )) {
                tmpLine[ strlen( tmpLine ) - 1] = 0;
                strTrimInPlace( tmpLine );
                if ( 0 != strlen( tmpLine ) ) {
                    // strToLowerInPlace( tmpLine ); 
                    strlcpy( wordList[ i ], tmpLine, WORDLISTMAXSTRSZ );
                    if ( (++i) > WORDLISTMAXELEM) break;
                }
            }
        }
        fclose( fpr );
    }
    return( i );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
callq 0xf829
addq $0x20, %r15
cmpq $0x8000, %r15           # imm = 0x8000
jne 0x1107e
leaq 0xadf0(%rip), %rsi      # 0x1be8b
movq %r14, %rdi
callq 0x8320
testq %rax, %rax
je 0x11131
movq %rax, %r14
movq %rax, %rdi
callq 0x8270
xorl %ebp, %ebp
testl %eax, %eax
jne 0x11127
xorl %ebp, %ebp
movq %rsp, %r15
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x8200
testq %rax, %rax
je 0x1111b
movq %r15, %rdi
callq 0x8120
movb $0x0, -0x1(%rax,%r15)
movq %r15, %rdi
callq 0xf92f
cmpb $0x0, (%rsp)
je 0x1111b
movslq %ebp, %r12
movq %r12, %rdi
shlq $0x5, %rdi
addq %rbx, %rdi
movl $0x20, %edx
movq %r15, %rsi
callq 0xf384
leal 0x1(%r12), %ebp
cmpl $0x3ff, %r12d           # imm = 0x3FF
jg 0x11127
movq %r14, %rdi
callq 0x8270
testl %eax, %eax
je 0x110c2
movq %r14, %rdi
callq 0x8100
jmp 0x11136
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiWordListCheck
int apiWordListCheck( char *stringTested, wordList_t wordList )
{
    int i;
    int isMatch = 0;

    for (i=0; i<WORDLISTMAXELEM; i++) {

        if ( wordList[i][0] == 0 ) break;
        if ( NULL != strcasestr( stringTested, wordList[i] )) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpb $0x0, (%r14,%r12)
je 0x11187
leaq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x8350
testq %rax, %rax
jne 0x11182
addq $0x20, %r12
cmpq $0x8000, %r12           # imm = 0x8000
jne 0x1115b
jmp 0x11187
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiWordListCheckExact
int apiWordListCheckExact( char *stringTested, wordList_t wordList )
{
    int i;
    int isMatch = 0;

    for (i=0; i<WORDLISTMAXELEM; i++) {

        if ( wordList[i][0] == 0 ) break;
        if ( 0 == strncmp( stringTested, wordList[i], WORDLISTMAXSTRSZ ) ) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpb $0x0, (%r14,%r12)
je 0x111d8
leaq (%r14,%r12), %rsi
movl $0x20, %edx
movq %r15, %rdi
callq 0x8080
testl %eax, %eax
je 0x111d3
addq $0x20, %r12
cmpq $0x8000, %r12           # imm = 0x8000
jne 0x111a8
jmp 0x111d8
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListAdd
int apiIdListAdd( char *connectID, idList_t idList ) 
{
    int i, j;
 
    for ( j = -1, i = 0; i<IDLISTMAXELEM; i++ ) {
        if ( 0 == strlen( idList[i] )) {   // found an empty slot
            j = i;
            break;
        }
    }
    if (( j != -1 ) && ( connectID != NULL ))
        strlcpy( idList[j], connectID, IDLISTMAXSTRSZ );

    return j;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
xorl %ebx, %ebx
movl $0x100, %ecx            # imm = 0x100
cmpb $0x0, (%rsi)
je 0x11208
incq %rbx
addq %rcx, %rsi
cmpq %rcx, %rbx
jne 0x111f1
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1121d
testq %rax, %rax
je 0x1121d
movl $0x100, %edx            # imm = 0x100
movq %rsi, %rdi
movq %rax, %rsi
callq 0xf384
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListGet
char *apiIdListGet( idList_t idList, int index )
{
    static char retStr[IDLISTMAXSTRSZ];
     
    strclr( retStr );
    if ( index < IDLISTMAXELEM ) {
        strlcpy( retStr, idList[ index ], IDLISTMAXSTRSZ );
    }
    return retStr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc0123(%rip), %rdi     # 0xd1380
callq 0xf829
cmpl $0xff, %ebp
jg 0x11288
movslq %ebp, %rax
shlq $0x8, %rax
addq %rax, %rbx
leaq 0xc0105(%rip), %rdi     # 0xd1380
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rsi
callq 0xf384
leaq 0xc00f1(%rip), %rax     # 0xd1380
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListRead
int apiIdListRead( char *listFile, idList_t idList )
{
    int  i, idType;
    char tmpLine[1024], testGUID[256]; //  *w;
    FILE *fpr;

    for (i=0; i<IDLISTMAXELEM; i++) strclr( idList[i] );

    // EPIC

    i = -1;
    if (NULL != (fpr = fopen( listFile, "rt" ))) {
        i = 0;
        while (!feof( fpr )) {
            if (NULL != fgets( tmpLine, 1024, fpr )) {
                tmpLine[ strlen( tmpLine ) - 1] = 0;

                strlcpy( testGUID, tmpLine, IDEPICIDLEN+1 );           // 65-char EPIC ID + terminator
                if ( 2 == ( idType = rosterIsValidGUID( testGUID ) )) {
                    strlcpy( idList[i++], testGUID, IDEPICIDLEN+1 );
                }
                else {
                    strlcpy( testGUID, tmpLine, IDSTEAMID64LEN+1 );   // 17-char Steam ID + terminator
                    if ( 1 == ( idType = rosterIsValidGUID ( testGUID ))) { 
                        strlcpy( idList[i++], testGUID, IDSTEAMID64LEN+1 );
                    }
                } 
                if ( i >= (IDLISTMAXELEM-1) ) break;    // check for overflow
            }
        }
        fclose( fpr );
    }
    return( i );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
callq 0xf829
addq $0x100, %r15            # imm = 0x100
cmpq $0x10000, %r15          # imm = 0x10000
jne 0x112b0
leaq 0xabbb(%rip), %rsi      # 0x1be8b
movq %r14, %rdi
callq 0x8320
testq %rax, %rax
je 0x113a5
movq %rax, %r14
movq %rax, %rdi
callq 0x8270
xorl %ebp, %ebp
testl %eax, %eax
jne 0x1139b
xorl %ebp, %ebp
leaq 0x100(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x8200
testq %rax, %rax
je 0x1138b
movq %r15, %rdi
callq 0x8120
movb $0x0, -0x1(%rax,%r15)
movl $0x42, %r13d
movl $0x42, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xf384
movq %r12, %rdi
callq 0x14378
cmpl $0x2, %eax
je 0x1136c
movl $0x12, %r13d
movl $0x12, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xf384
movq %r12, %rdi
callq 0x14378
cmpl $0x1, %eax
jne 0x11383
movslq %ebp, %rdi
incl %ebp
shlq $0x8, %rdi
addq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf384
cmpl $0xfe, %ebp
jg 0x1139b
movq %r14, %rdi
callq 0x8270
testl %eax, %eax
je 0x11303
movq %r14, %rdi
callq 0x8100
jmp 0x113aa
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiBadNameCheck
int apiBadNameCheck( char *nameIn, int exactMatch )
{
    if ( exactMatch ) 
        return (apiWordListCheckExact( nameIn, badWordsList )); 
    else
        return (apiWordListCheck( nameIn, badWordsList )); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
je 0x113e7
leaq 0xc00ac(%rip), %rsi     # 0xd1480
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11195
xorl %ebx, %ebx
leaq 0xc0090(%rip), %r15     # 0xd1480
xorl %r12d, %r12d
cmpb $0x0, (%r12,%r15)
je 0x1141f
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x8350
testq %rax, %rax
jne 0x1141a
addq $0x20, %r12
cmpq $0x8000, %r12           # imm = 0x8000
jne 0x113f3
jmp 0x1141f
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListCheck
int apiIdListCheck( char *connectID, idList_t idList )
{
    int i;
    int isMatch = 0;

    for (i=0; i<IDLISTMAXELEM; i++) {
        if (0 == strcmp( idList[i], connectID )) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
movq %r14, %rsi
callq 0x8220
testl %eax, %eax
je 0x1145f
addq $0x100, %r15            # imm = 0x100
cmpq $0x10000, %r15          # imm = 0x10000
jne 0x1143b
xorl %eax, %eax
jmp 0x11464
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListMatch
int apiIdListMatch( char *connectID, idList_t idList )
{
    int i;
    int isMatch = 0;

    for ( i=0; i<IDLISTMAXELEM; i++ ) {
        if ( 0 == strlen( idList[i] )) 
            break;
        if (NULL != strcasestr( connectID, idList[i] )) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpb $0x0, (%r14,%r12)
je 0x114ac
leaq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x8350
testq %rax, %rax
jne 0x114a7
addq $0x100, %r12            # imm = 0x100
cmpq $0x10000, %r12          # imm = 0x10000
jne 0x1147d
jmp 0x114ac
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiSyntheticObjDispatch
int _apiSyntheticObjDispatch(char *activeObjectRaw )   
{
    char strOut[API_LINE_STRING_MAX], *w;
    int i, errCode = 0;

    // Repackage the log line into something we can use -
    // a space delimited parameters that we can parse easily
    //
    strlcpy( strOut, "~SYNTHOBJ~", API_LINE_STRING_MAX ); 
    for (i=0; i<5; i++) {
        w = getWord( activeObjectRaw, i, " =\"\'.:" );
        if  ( w != NULL )  {
            strlcat( strOut, " ", API_LINE_STRING_MAX );
            strlcat( strOut, w,   API_LINE_STRING_MAX );
        }
        else  {
            errCode = 1;
            break;
        }
    }

    // Update some internal variables and finally call a Synthetic 
    // dispatcher to signal the plugins // something has updated.
    //
    if ( !errCode ) {
        // Update the database with ActiveObject content just decoded.
        // 
        rosterSetMapName( getWord( strOut, 3, " " ));
        rosterSetObjective( getWord( strOut, 5, " " ), getWord( strOut, 1, " " ));
        logPrintf( LOG_LEVEL_DEBUG, "api", "Updating DB with ActiveObject ::%s::%s::%s::", 
            getWord( strOut, 3, " " ), getWord( strOut, 5, " " ), getWord( strOut, 1, " " ) );

        // Generate a Synthetic event signalling change in ActiveObject content
        // 
        eventsDispatch( strOut );                        // dispatch subscribed plugin Callbacks 
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movabsq $0x424f48544e59537e, %rax # imm = 0x424F48544E59537E
movq %rsp, %r14
movq %rax, (%r14)
movl $0x7e4a42, 0x7(%r14)    # imm = 0x7E4A42
xorl %ebp, %ebp
leaq 0xc907(%rip), %r15      # 0x1de78
leaq 0xabd6(%rip), %r12      # 0x1c14e
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xf82d
testq %rax, %rax
je 0x11669
movq %rax, %r13
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %r12, %rsi
callq 0xf310
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %r13, %rsi
callq 0xf310
incl %ebp
cmpl $0x5, %ebp
jne 0x11578
leaq 0xab8f(%rip), %r14      # 0x1c14e
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0xf82d
movq %rax, %rdi
callq 0x1456b
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0xf82d
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xf82d
movq %r15, %rdi
movq %rax, %rsi
callq 0x1452e
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0xf82d
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0xf82d
movq %rax, %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xf82d
leaq 0xc83a(%rip), %rsi      # 0x1de7f
leaq 0xc837(%rip), %rdx      # 0x1de83
movl $0x3, %edi
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1a3e3
movq %rbx, %rdi
callq 0xd4f0
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiFetchGameState
static int _apiFetchGameState( void )
{
    int errCode = 1;

    strlcpy( gameStateCurrent, apiGameModePropertyGet( "activeobjective" ), API_ROSTER_STRING_MAX );
    if ( 0 != strlen( gameStateCurrent ) ) {
        lastGameStateSuccessTime = apiTimeGet();   // record last time value read succesfully
        errCode = 0;
        if ( 0 != strncmp( gameStatePrevious, gameStateCurrent, API_ROSTER_STRING_MAX )) {
            strlcpy( gameStatePrevious, gameStateCurrent, API_ROSTER_STRING_MAX );
            logPrintf( LOG_LEVEL_INFO, "api", "ActiveObjective ::%s::", gameStatePrevious );
            _apiSyntheticObjDispatch( gameStatePrevious );
        }
    }
    return errCode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xceed(%rip), %rdi      # 0x1e6bf
callq 0x131f2
leaq 0x1461f2(%rip), %rdi    # 0x1579d0
leaq 0x15a3fb(%rip), %rsi    # 0x16bbe0
movl $0x4000, %edx           # imm = 0x4000
callq 0xf384
cmpb $0x0, 0x1461da(%rip)    # 0x1579d0
je 0x11861
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x82a0
leaq 0xdbda8(%rip), %rdi     # 0xed5b0
leaq 0x1461c1(%rip), %rsi    # 0x1579d0
movl $0x4000, %edx           # imm = 0x4000
callq 0x8080
testl %eax, %eax
je 0x11866
leaq 0xdbd8c(%rip), %r14     # 0xed5b0
leaq 0x1461a5(%rip), %rsi    # 0x1579d0
movl $0x4000, %edx           # imm = 0x4000
movq %r14, %rdi
callq 0xf384
leaq 0xc640(%rip), %rsi      # 0x1de7f
leaq 0xce89(%rip), %rdx      # 0x1e6cf
xorl %ebx, %ebx
movl $0x2, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1a3e3
movq %r14, %rdi
callq 0x1153c
jmp 0x11866
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiGetServerNameRCON
char *apiGetServerNameRCON( int forceCacheRefresh )
{
    static char hostName[256];
    static unsigned long timeLastRead = 0;

    // check to see if this is a first-time call, or caller is forcing a refrehs
    //
    if ( (timeLastRead == 0L) || forceCacheRefresh ) {
    
        // fetch from RCON.  apiGameModePropertyGet returns an empty string
        // (not NULL) on interface error.
        //
        strlcpy( hostName, apiGameModePropertyGet( "serverhostname" ), 256 ); 
        if ( strlen( hostName ) != 0 )  {
            timeLastRead = apiTimeGet();
            logPrintf( LOG_LEVEL_INFO, "api", "RCON successful read of serverhostname ::%s::", hostName );
        }
        else {
            strlcpy( hostName, "Unknown", 256 );
            logPrintf( LOG_LEVEL_INFO, "api", "RCON Error! -- Failed to read serverhostname." );
        }
    }
    return ( hostName );
}

// Assembly:
testl %edi, %edi
jne 0x11882
cmpq $0x0, 0x166664(%rip)    # 0x177ee0
jne 0x11910
pushq %rax
leaq 0xcc70(%rip), %rdi      # 0x1e4fa
callq 0x131f2
leaq 0x16654a(%rip), %rdi    # 0x177de0
leaq 0x15a343(%rip), %rsi    # 0x16bbe0
movl $0x100, %edx            # imm = 0x100
callq 0xf384
cmpb $0x0, 0x166532(%rip)    # 0x177de0
je 0x118e1
xorl %edi, %edi
callq 0x82a0
movq %rax, 0x166622(%rip)    # 0x177ee0
leaq 0xc5ba(%rip), %rsi      # 0x1de7f
leaq 0xcc3d(%rip), %rdx      # 0x1e509
leaq 0x16650d(%rip), %rcx    # 0x177de0
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a3e3
jmp 0x1190c
movabsq $0x6e776f6e6b6e55, %rax # imm = 0x6E776F6E6B6E55
movq %rax, 0x1664ee(%rip)    # 0x177de0
leaq 0xc586(%rip), %rsi      # 0x1de7f
leaq 0xcc37(%rip), %rdx      # 0x1e537
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a3e3
addq $0x8, %rsp
leaq 0x1664c9(%rip), %rax    # 0x177de0
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiSessionLogCB
int _apiSessionLogCB( char *strIn )
{
    char _currSession[API_LINE_STRING_MAX];

    rosterParseSessionID( strIn, API_LINE_STRING_MAX, _currSession );
    rosterSetSessionID( _currSession );

    logPrintf( LOG_LEVEL_INFO, "api", "SessionID: ::%s::", _currSession );
    return 0;
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsp, %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x156ba
movq %rbx, %rdi
callq 0x14512
leaq 0xc4cd(%rip), %rsi      # 0x1de7f
leaq 0xc5c4(%rip), %rdx      # 0x1df7d
movl $0x2, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a3e3
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiBPCharInitCB
int _apiBPCharInitCB( char *strIn )
{
    int i;

    strclr( _cachedName );
    for ( i=0; i<API_MAXENTITIES; i++ ) {
        strclr( soldierTranslate[ i ].charID );
        strclr( soldierTranslate[ i ].playerName );
    }
    logPrintf( LOG_LEVEL_INFO, "api", "BPChar Translation Table cleared" );
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcfac2(%rip), %rdi     # 0xe14a0
callq 0xf829
leaq 0xcfbb6(%rip), %rbx     # 0xe15a0
movl $0x40, %r14d
movq %rbx, %rdi
callq 0xf829
leaq 0x100(%rbx), %rdi
callq 0xf829
addq $0x200, %rbx            # imm = 0x200
decq %r14
jne 0x119f0
leaq 0xc468(%rip), %rsi      # 0x1de7f
leaq 0xc571(%rip), %rdx      # 0x1df8f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a3e3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiBPPlayerCount
int apiBPPlayerCount( void )
{
    int i;
    int countPlayers = 0;
    long devOverride = 0L;

    for ( i=0; i<API_MAXENTITIES; i++ ) {
        if (0 != strlen( soldierTranslate[ i ].playerName ) ) countPlayers++;
    }

    if ( 0L != (devOverride = p2pGetL( "dev.p2p.humans", 0L )) ) {
        countPlayers = 0xffL & devOverride;
    }

    return countPlayers;
}

// Assembly:
pxor %xmm0, %xmm0
xorl %eax, %eax
leaq 0xcfb57(%rip), %rcx     # 0xe15a0
pcmpeqd %xmm2, %xmm2
movdqa 0xc3db(%rip), %xmm3     # 0x1de30
pxor %xmm1, %xmm1
movzbl 0x100(%rax,%rcx), %edx
movzbl 0x300(%rax,%rcx), %esi
movzbl 0x500(%rax,%rcx), %edi
shll $0x8, %esi
orl %edx, %esi
shll $0x10, %edi
orl %esi, %edi
movl 0x700(%rax,%rcx), %edx
shll $0x18, %edx
orl %edi, %edx
movd %edx, %xmm4
pcmpeqb %xmm0, %xmm4
pxor %xmm2, %xmm4
punpcklbw %xmm4, %xmm4    # xmm4 = xmm4[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm4, %xmm4    # xmm4 = xmm4[0,0,1,1,2,2,3,3]
pand %xmm3, %xmm4
paddd %xmm4, %xmm1
addq $0x800, %rax            # imm = 0x800
cmpq $0x8000, %rax           # imm = 0x8000
jne 0x11a59
pushq %rbx
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
paddd %xmm0, %xmm1
movd %xmm1, %ebx
leaq 0xac6d(%rip), %rdi      # 0x1c73c
xorl %esi, %esi
callq 0x181e1
testq %rax, %rax
movzbl %al, %eax
cmovel %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiBPCharDisconnectCB
int _apiBPCharDisconnectCB( char *strIn )
{
    char *w, *n = NULL;
    int i;

    if ( NULL != (w = strstr( strIn, SS_SUBSTR_BP_PLAYER_DISCONN ) )) {
        w = strstr( strIn, "BP_Character_Player" );
        if ( w != NULL ) {
            if ( NULL != (n = getWord( w, 0, " .'" )) ) {
                // printf("\nDisconnect ::%s::\n", n);
                ;
            }
        }
    }

    if ( n != NULL ) {

        // Remove from translation database
        // Check all entries and remove duplicates to be safe
        //
        for ( i = 0; i<API_MAXENTITIES; i++ )  {
            if ( 0 == strcmp( n, soldierTranslate[ i ].charID )) {
                logPrintf( LOG_LEVEL_INFO, "api", "BPChar '%s' unbound from '%s'", n, soldierTranslate[ i ].playerName );
                strclr( soldierTranslate[ i ].charID     );
                strclr( soldierTranslate[ i ].playerName );
            }
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xad35(%rip), %rsi      # 0x1ca0d
callq 0x83b0
testq %rax, %rax
je 0x11d77
leaq 0xc2dd(%rip), %rsi      # 0x1dfca
movq %rbx, %rdi
callq 0x83b0
testq %rax, %rax
je 0x11d77
leaq 0xc2dd(%rip), %rdx      # 0x1dfde
movq %rax, %rdi
xorl %esi, %esi
callq 0xf82d
testq %rax, %rax
je 0x11d77
movq %rax, %rbx
leaq 0xcf886(%rip), %r14     # 0xe15a0
movl $0x40, %ebp
leaq 0xc159(%rip), %r15      # 0x1de7f
leaq 0xc2cd(%rip), %r12      # 0x1dffa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8220
testl %eax, %eax
jne 0x11d6b
leaq 0x100(%r14), %r13
movl $0x2, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x1a3e3
movq %r14, %rdi
callq 0xf829
movq %r13, %rdi
callq 0xf829
addq $0x200, %r14            # imm = 0x200
decq %rbp
jne 0x11d2d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/api.c
// Function: apiMapChangeCB
int _apiMapChangeCB( char *strIn )
{
    char _currMap[API_LINE_STRING_MAX];
    int   i;
    int errCode;

    // There are two ways to find the current map.  The code below works by watching
    // the Insurgency.log file which works for all game modes.  For Co-op this is 
    // later superceded by synthetic map change event, reading data from activeobjectives
    // gamemodeproperty.
    //
    rosterParseMapname( strIn, API_LINE_STRING_MAX, _currMap );
    strClean( _currMap );
    rosterSetMapName( _currMap );

    _apiBPCharInitCB( strIn );

    // on map change, clear the objectives
    //
    for (i=0; i<API_OBJECTIVES_MAX; i++) strclr( _objectiveListCache[i]) ;
    logPrintf(LOG_LEVEL_INFO, "api", "Map change to ::%s:: and resetting the internal objectives cache", _currMap );


    // Update the change in GameState.  This may fail on some slower servers, so the following
    // routine is also called by the periodic CB. 
    // 
    errCode = _apiFetchGameState();
    logPrintf( LOG_LEVEL_INFO, "api", "MapChange ActiveObjective update::%s:: and Error ::%d::", gameStatePrevious, errCode );

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsp, %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x15720
movq %rbx, %rdi
callq 0xf9a9
movq %rbx, %rdi
callq 0x1456b
callq 0x119d3
xorl %ebx, %ebx
leaq 0xd77ea(%rip), %r14     # 0xe95b0
leaq (%r14,%rbx), %rdi
callq 0xf829
addq $0x100, %rbx            # imm = 0x100
cmpq $0x4000, %rbx           # imm = 0x4000
jne 0x11dc6
leaq 0xc099(%rip), %rbx      # 0x1de7f
leaq 0xc22b(%rip), %rdx      # 0x1e018
movq %rsp, %rcx
movl $0x2, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1a3e3
callq 0x117c7
leaq 0xc24e(%rip), %rdx      # 0x1e059
leaq 0xdb79e(%rip), %rcx     # 0xed5b0
movl $0x2, %edi
movq %rbx, %rsi
movl %eax, %r8d
xorl %eax, %eax
callq 0x1a3e3
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq