LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8a90
movq %rax, %rdi
callq 0x9370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12616(%rip), %rsi     # 0x2576a
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0xc0552(%rip)     # 0xd36b8
movq -0x8(%rbp), %rdi
leaq 0x12612(%rip), %rsi     # 0x25783
movsd 0xfe8f(%rip), %xmm0     # 0x23008
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0xc0534(%rip)     # 0xd36bc
movq -0x8(%rbp), %rdi
leaq 0x12611(%rip), %rsi     # 0x257a4
leaq 0x12623(%rip), %rdx     # 0x257bd
callq 0x9430
movq %rax, %rsi
leaq 0xc050f(%rip), %rdi     # 0xd36b8
addq $0x408, %rdi            # imm = 0x408
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x12623(%rip), %rsi     # 0x257e8
leaq 0x12636(%rip), %rdx     # 0x25802
callq 0x9430
movq %rax, %rsi
leaq 0xc04dd(%rip), %rdi     # 0xd36b8
addq $0x8, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x12636(%rip), %rsi     # 0x2582a
leaq 0x12648(%rip), %rdx     # 0x25843
callq 0x9430
movq %rax, %rsi
leaq 0xc04ae(%rip), %rdi     # 0xd36b8
addq $0x808, %rdi            # imm = 0x808
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
callq 0x93f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x187d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11d6f(%rip), %rsi     # 0x24fdb
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x13295
movq -0x8(%rbp), %rdi
leaq 0x10d7b(%rip), %rsi     # 0x23fff
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x13338
movl 0xc0421(%rip), %eax     # 0xd36bc
movl %eax, -0xc(%rbp)
callq 0x17fe0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jl 0x132f0
leaq 0x12593(%rip), %rdi     # 0x25846
leaq 0x14728(%rip), %rsi     # 0x279e2
callq 0x176f0
leaq 0xc03f2(%rip), %rdi     # 0xd36b8
addq $0x408, %rdi            # imm = 0x408
movb $0x0, %al
callq 0x178d0
movl $0x2, %edi
leaq 0x12572(%rip), %rsi     # 0x25852
leaq 0x124d6(%rip), %rdx     # 0x257bd
movb $0x0, %al
callq 0x21bf0
jmp 0x13336
leaq 0x1254f(%rip), %rdi     # 0x25846
leaq 0xc03ba(%rip), %rsi     # 0xd36b8
addq $0x808, %rsi            # imm = 0x808
callq 0x176f0
leaq 0xc03a7(%rip), %rdi     # 0xd36b8
addq $0x8, %rdi
movb $0x0, %al
callq 0x178d0
movl $0x2, %edi
leaq 0x1252a(%rip), %rsi     # 0x25852
leaq 0x124d3(%rip), %rdx     # 0x25802
movb $0x0, %al
callq 0x21bf0
jmp 0x13338
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x13130
cmpl $0x0, 0xc0284(%rip)     # 0xd36b8
jne 0x13442
movl $0x0, -0x4(%rbp)
jmp 0x13504
movl $0x3, %edi
leaq -0x21e(%rip), %rsi      # 0x13230
callq 0xee50
movl $0x4, %edi
leaq -0x11f(%rip), %rsi      # 0x13340
callq 0xee50
movl $0x1, %edi
leaq -0x110(%rip), %rsi      # 0x13360
callq 0xee50
movl $0x2, %edi
leaq -0x111(%rip), %rsi      # 0x13370
callq 0xee50
movl $0x5, %edi
leaq -0x112(%rip), %rsi      # 0x13380
callq 0xee50
movl $0x6, %edi
leaq -0x103(%rip), %rsi      # 0x133a0
callq 0xee50
movl $0x7, %edi
leaq -0xf4(%rip), %rsi       # 0x133c0
callq 0xee50
movl $0x8, %edi
leaq -0xf5(%rip), %rsi       # 0x133d0
callq 0xee50
movl $0x9, %edi
leaq -0xe6(%rip), %rsi       # 0x133f0
callq 0xee50
movl $0xa, %edi
leaq -0xe7(%rip), %rsi       # 0x13400
callq 0xee50
movl $0xb, %edi
leaq -0xe8(%rip), %rsi       # 0x13410
callq 0xee50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xc18c9(%rip), %rdi     # 0xd5280
movl $0x4000, %edx           # imm = 0x4000
callq 0x11bc0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0xc18ab(%rip), %rdi     # 0xd5280
callq 0x8110
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x13a5c
movslq -0xc(%rbp), %rax
leaq 0xc1891(%rip), %rcx     # 0xd5280
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
subl $0x2f, %eax
je 0x13a3d
jmp 0x139fd
movl -0x14(%rbp), %eax
subl $0x3c, %eax
je 0x13a1b
jmp 0x13a07
movl -0x14(%rbp), %eax
subl $0x3e, %eax
je 0x13a2c
jmp 0x13a11
movl -0x14(%rbp), %eax
subl $0x5c, %eax
je 0x13a3d
jmp 0x13a4c
movslq -0xc(%rbp), %rcx
leaq 0xc185a(%rip), %rax     # 0xd5280
movb $0x5b, (%rax,%rcx)
jmp 0x13a4c
movslq -0xc(%rbp), %rcx
leaq 0xc1849(%rip), %rax     # 0xd5280
movb $0x5d, (%rax,%rcx)
jmp 0x13a4c
movslq -0xc(%rbp), %rcx
leaq 0xc1838(%rip), %rax     # 0xd5280
movb $0x7c, (%rax,%rcx)
jmp 0x13a4e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x139c8
xorl %eax, %eax
cmpl 0xc0860(%rip), %eax     # 0xd42c4
jne 0x13ae5
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq 0xc1806(%rip), %rdi     # 0xd5280
callq 0x8110
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x13ae3
movslq -0xc(%rbp), %rcx
leaq 0xc17ec(%rip), %rax     # 0xd5280
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x13ad6
callq 0x83b0
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
leaq 0xc17d0(%rip), %rcx     # 0xd5280
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x13ad4
movslq -0xc(%rbp), %rcx
leaq 0xc17b0(%rip), %rax     # 0xd5280
movb $0x2a, (%rax,%rcx)
jmp 0x13ad6
jmp 0x13ad8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13a6d
jmp 0x13ae5
leaq 0xc1794(%rip), %rax     # 0xd5280
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbfefd(%rip), %rdi     # 0xd42c0
addq $0x8, %rdi
leaq 0x11726(%rip), %rsi     # 0x25af4
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1442c
xorl %eax, %eax
cmpl 0xc0b6b(%rip), %eax     # 0xd4f54
je 0x143fd
movq -0x10(%rbp), %rdi
leaq 0x11701(%rip), %rsi     # 0x25af7
movb $0x0, %al
callq 0x8230
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x17620
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x11708(%rip), %rsi     # 0x25b24
movb $0x0, %al
callq 0x8230
movq -0x10(%rbp), %rdi
callq 0x80f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x13510
cmpl $0x0, 0xbfe6c(%rip)     # 0xd42c0
jne 0x14462
movl $0x0, -0x4(%rbp)
jmp 0x14535
movl $0x3, %edi
leaq -0x96e(%rip), %rsi      # 0x13b00
callq 0xee50
movl $0x4, %edi
leaq -0x35f(%rip), %rsi      # 0x14120
callq 0xee50
movl $0x1, %edi
leaq -0x340(%rip), %rsi      # 0x14150
callq 0xee50
movl $0x2, %edi
leaq -0x321(%rip), %rsi      # 0x14180
callq 0xee50
movl $0x5, %edi
leaq -0x322(%rip), %rsi      # 0x14190
callq 0xee50
movl $0x6, %edi
leaq -0x303(%rip), %rsi      # 0x141c0
callq 0xee50
movl $0x7, %edi
leaq -0x2f4(%rip), %rsi      # 0x141e0
callq 0xee50
movl $0x8, %edi
leaq -0x2f5(%rip), %rsi      # 0x141f0
callq 0xee50
movl $0x9, %edi
leaq -0x2f6(%rip), %rsi      # 0x14200
callq 0xee50
movl $0xa, %edi
leaq -0x2f7(%rip), %rsi      # 0x14210
callq 0xee50
movl $0xb, %edi
leaq -0x2f8(%rip), %rsi      # 0x14220
callq 0xee50
movl $0xf, %edi
leaq -0x179(%rip), %rsi      # 0x143b0
callq 0xee50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xc4d33(%rip), %rdi     # 0xd9290
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x145d7
jmp 0x1456e
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq 0xc4d10(%rip), %rdi     # 0xd9290
leaq 0xfbd1(%rip), %rdx      # 0x24158
callq 0x122d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14599
jmp 0x145d5
movq -0x18(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x145ae
jmp 0x145d5
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x125b0
jmp 0x1456e
jmp 0x145d7
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x14622
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x122b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x145fa
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
leaq 0xf85f(%rip), %rsi      # 0x23e93
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x428(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14715
movl $0x0, -0x14(%rbp)
movq -0x428(%rbp), %rdi
callq 0x8250
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14672
jmp 0x14709
leaq -0x420(%rbp), %rdi
movq -0x428(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x81e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14704
leaq -0x420(%rbp), %rdi
callq 0x8110
subq $0x1, %rax
movb $0x0, -0x420(%rbp,%rax)
leaq -0x420(%rbp), %rdi
callq 0x12450
leaq -0x420(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14702
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq -0x420(%rbp), %rsi
movl $0x20, %edx
callq 0x11bc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x400, %eax            # imm = 0x400
jle 0x14700
jmp 0x14709
jmp 0x14702
jmp 0x14704
jmp 0x14655
movq -0x428(%rbp), %rdi
callq 0x80f0
movl -0x14(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x147a8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x14770
jmp 0x147a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1479b
movl $0x1, -0x18(%rbp)
jmp 0x147a8
jmp 0x1479d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1474e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x1483b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x14800
jmp 0x1483b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movl $0x20, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1482e
movl $0x1, -0x18(%rbp)
jmp 0x1483b
jmp 0x14830
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x147de
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x148aa
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1489d
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x148aa
jmp 0x1489f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1486e
cmpl $-0x1, -0x18(%rbp)
je 0x148d4
cmpq $0x0, -0x8(%rbp)
je 0x148d4
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListClear
int apiIdListClear( idList_t idList )
{
    int i;

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x1491b
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x122b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x148f3
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xc4a4a(%rip), %rdi     # 0xd9390
callq 0x122b0
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x14974
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rsi
leaq 0xc4a26(%rip), %rdi     # 0xd9390
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq 0xc4a15(%rip), %rax     # 0xd9390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x14bfd
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x14bf0
movl $0x1, -0x18(%rbp)
jmp 0x14bfd
jmp 0x14bf2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14bbe
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x14c8f
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x14c57
jmp 0x14c8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rsi
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x14c82
movl $0x1, -0x18(%rbp)
jmp 0x14c8f
jmp 0x14c84
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14c2e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
leaq 0x115f9(%rip), %rdi     # 0x266df
callq 0x17720
movq %rax, %rsi
leaq 0x14a8db(%rip), %rdi    # 0x15f9d0
movl $0x4000, %edx           # imm = 0x4000
callq 0x11bc0
leaq 0x14a8ca(%rip), %rdi    # 0x15f9d0
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1518f
callq 0x150c0
movq %rax, 0x1faf4f(%rip)    # 0x210070
movl $0x0, -0x4(%rbp)
leaq 0xe0491(%rip), %rdi     # 0xf55c0
leaq 0x14a89a(%rip), %rsi    # 0x15f9d0
movl $0x4000, %edx           # imm = 0x4000
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1518d
leaq 0xe0471(%rip), %rdi     # 0xf55c0
leaq 0x14a87a(%rip), %rsi    # 0x15f9d0
movl $0x4000, %edx           # imm = 0x4000
callq 0x11bc0
movl $0x2, %edi
leaq 0x10d2b(%rip), %rsi     # 0x25e97
leaq 0x1157c(%rip), %rdx     # 0x266ef
leaq 0xe0446(%rip), %rcx     # 0xf55c0
movb $0x0, %al
callq 0x21bf0
leaq 0xe0438(%rip), %rdi     # 0xf55c0
callq 0x14d70
jmp 0x1518f
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x16ad2d(%rip)    # 0x17fee0
je 0x151bf
cmpl $0x0, -0x4(%rbp)
je 0x15254
leaq 0x11354(%rip), %rdi     # 0x2651a
callq 0x17720
movq %rax, %rsi
leaq 0x16ac0b(%rip), %rdi    # 0x17fde0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq 0x16abfa(%rip), %rdi    # 0x17fde0
callq 0x8110
cmpq $0x0, %rax
je 0x15220
callq 0x150c0
movq %rax, 0x16ace3(%rip)    # 0x17fee0
movl $0x2, %edi
leaq 0x10c8e(%rip), %rsi     # 0x25e97
leaq 0x11319(%rip), %rdx     # 0x26529
leaq 0x16abc9(%rip), %rcx    # 0x17fde0
movb $0x0, %al
callq 0x21bf0
jmp 0x15252
leaq 0x16abb9(%rip), %rdi    # 0x17fde0
leaq 0x107dd(%rip), %rsi     # 0x25a0b
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl $0x2, %edi
leaq 0x10c53(%rip), %rsi     # 0x25e97
leaq 0x1130c(%rip), %rdx     # 0x26557
movb $0x0, %al
callq 0x21bf0
jmp 0x15254
leaq 0x16ab85(%rip), %rax    # 0x17fde0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiPlayerConnectedCB
int _apiPlayerConnectedCB( char *strIn )
{
    logPrintf( LOG_LEVEL_RAWDUMP, "api", "Player Connected callback ::%s::", strIn );

    // Add delay here because there is a time lag between log file reporting 'add connection'
    // until the new player shows up on RCON roster read via the listplayer command.
    // The delay becomes more pronounced on a busy (CPU loaded) server state.
    //
    usleep( API_LOG2RCON_DELAY_MICROSEC );

    // Update the roster which also resets the schedule for next refresh
    // This routine resets the next alarm time 
    // 
    _apiPollAlarmCB("PlayerConnected");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x4, %edi
leaq 0x10bfb(%rip), %rsi     # 0x25e97
leaq 0x10c8a(%rip), %rdx     # 0x25f2d
movb $0x0, %al
callq 0x21bf0
movl $0x3d090, %edi          # imm = 0x3D090
callq 0x83c0
leaq 0x10c93(%rip), %rdi     # 0x25f4e
callq 0x14f40
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x1b0d0
leaq -0x110(%rbp), %rdi
callq 0x19340
leaq -0x110(%rbp), %rcx
movl $0x2, %edi
leaq 0x10b24(%rip), %rsi     # 0x25e97
leaq 0x10c1b(%rip), %rdx     # 0x25f95
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd410d(%rip), %rdi     # 0xe94b0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x153f5
movslq -0xc(%rbp), %rax
leaq 0xd41f0(%rip), %rdi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rdi
callq 0x122b0
movslq -0xc(%rbp), %rax
leaq 0xd41d9(%rip), %rdi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x122b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x153af
movl $0x2, %edi
leaq 0x10a96(%rip), %rsi     # 0x25e97
leaq 0x10b9f(%rip), %rdx     # 0x25fa7
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x15492
movslq -0x4(%rbp), %rax
leaq 0xd4151(%rip), %rdi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x15485
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15487
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1544e
leaq 0xf2d3(%rip), %rdi      # 0x2476c
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x154bd
movq -0x10(%rbp), %rax
andq $0xff, %rax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiBPCharNameCB
int _apiBPCharNameCB( char *strIn )
{
    char *w = NULL, *n = NULL;
    int errCode = 1;

    // logPrintf( LOG_LEVEL_INFO, "api", "apiBPCharNameCB ::%s:: ", strIn );

    // for unmodded server processing and legacy MedicDemo mod
    // 
    if ( errCode ) { 
        if ( NULL != (w = strstr( strIn, SS2_SUBSTR_PLAYERCONN1 ) )) {
            if (NULL != ( n = &w[ strlen( SS2_SUBSTR_PLAYERCONN1 ) ])) {
                if ( n != NULL ) {
                    strlcpy( _cachedName, n, 256 );
                    errCode = 0;
                }
            }
        }
    }

    // for compatibility with the "Medicon Mod"
    //
    if ( errCode ) {
        if ( NULL != (w = strstr( strIn, SS2_SUBSTR_PLAYERCONN2 ) )) {
            if (NULL != ( n = &w[ strlen( SS2_SUBSTR_PLAYERCONN2 ) ])) {
                if ( n != NULL ) {
                    strlcpy( _cachedName, n, 256 );
                    errCode = 0;
                }
            }
        }
    }

    // clean up the string
    // 
    if ( 0 == errCode )  {
        strClean( _cachedName );   
        strTrimInPlace( _cachedName );   
        logPrintf( LOG_LEVEL_INFO, "api", "BPChar Start Name ::%s:: ", _cachedName );
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x15553
movq -0x8(%rbp), %rdi
leaq 0xfeab(%rip), %rsi      # 0x253af
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x15551
movq -0x10(%rbp), %rcx
addq $0x1a, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1554f
cmpq $0x0, -0x18(%rbp)
je 0x1554d
movq -0x18(%rbp), %rsi
leaq 0xd3f74(%rip), %rdi     # 0xe94b0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl $0x0, -0x1c(%rbp)
jmp 0x1554f
jmp 0x15551
jmp 0x15553
cmpl $0x0, -0x1c(%rbp)
je 0x155b3
movq -0x8(%rbp), %rdi
leaq 0xfe86(%rip), %rsi      # 0x253ea
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x155b1
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x155af
cmpq $0x0, -0x18(%rbp)
je 0x155ad
movq -0x18(%rbp), %rsi
leaq 0xd3f14(%rip), %rdi     # 0xe94b0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl $0x0, -0x1c(%rbp)
jmp 0x155af
jmp 0x155b1
jmp 0x155b3
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jne 0x155f3
leaq 0xd3eef(%rip), %rdi     # 0xe94b0
callq 0x12530
leaq 0xd3ee3(%rip), %rdi     # 0xe94b0
callq 0x12450
movl $0x2, %edi
leaq 0x108b9(%rip), %rsi     # 0x25e97
leaq 0x109e3(%rip), %rdx     # 0x25fc8
leaq 0xd3ec4(%rip), %rcx     # 0xe94b0
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xf1ce(%rip), %rsi      # 0x24a3d
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x158c3
movq -0x8(%rbp), %rdi
leaq 0x10755(%rip), %rsi     # 0x25fe2
callq 0x8390
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x158c1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq 0x1074c(%rip), %rdx     # 0x25ff6
callq 0x122d0
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x158bf
jmp 0x158bf
jmp 0x158c1
jmp 0x158c3
cmpq $0x0, -0x18(%rbp)
je 0x15980
movl $0x0, -0x1c(%rbp)
cmpl $0x40, -0x1c(%rbp)
jge 0x1597e
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0xd3cc2(%rip), %rsi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1596e
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rax
leaq 0xd3c9f(%rip), %r8      # 0xe95b0
shlq $0x9, %rax
addq %rax, %r8
addq $0x100, %r8             # imm = 0x100
movl $0x2, %edi
leaq 0x1056c(%rip), %rsi     # 0x25e97
leaq 0x106e0(%rip), %rdx     # 0x26012
movb $0x0, %al
callq 0x21bf0
movslq -0x1c(%rbp), %rax
leaq 0xd3c6c(%rip), %rdi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rdi
callq 0x122b0
movslq -0x1c(%rbp), %rax
leaq 0xd3c55(%rip), %rdi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x122b0
jmp 0x15970
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x158d5
jmp 0x15980
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x1b180
leaq -0x110(%rbp), %rdi
callq 0x12530
leaq -0x110(%rbp), %rdi
callq 0x193e0
movq -0x8(%rbp), %rdi
callq 0x15390
movl $0x0, -0x114(%rbp)
cmpl $0x40, -0x114(%rbp)
jge 0x15a33
movslq -0x114(%rbp), %rax
leaq 0xdbbaa(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
callq 0x122b0
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x159ff
leaq -0x110(%rbp), %rcx
movl $0x2, %edi
leaq 0x10451(%rip), %rsi     # 0x25e97
leaq 0x105e3(%rip), %rdx     # 0x26030
movb $0x0, %al
callq 0x21bf0
callq 0x150d0
movl %eax, -0x118(%rbp)
movl -0x118(%rbp), %r8d
movl $0x2, %edi
leaq 0x10425(%rip), %rsi     # 0x25e97
leaq 0x105f8(%rip), %rdx     # 0x26071
leaq 0xdfb40(%rip), %rcx     # 0xf55c0
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiNameToCharacter
char *apiNameToCharacter( char *playerName )
{
    int i;
    static char w[ 256 ];

    strclr( w );
    for ( i = 0; i<API_MAXENTITIES; i++ )  {
        if ( 0 == strcmp( playerName, soldierTranslate[ i ].playerName )) {
            strlcpy( w, soldierTranslate[ i ].charID, 256 );
            break;
        }
    }
    return( w );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe3b0d(%rip), %rdi     # 0xf95c0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x15b21
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
leaq 0xd3adc(%rip), %rsi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rsi
addq $0x100, %rsi            # imm = 0x100
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x15b14
movslq -0xc(%rbp), %rax
leaq 0xd3ab6(%rip), %rsi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rsi
leaq 0xe3ab8(%rip), %rdi     # 0xf95c0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x15b21
jmp 0x15b16
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15abf
leaq 0xe3a98(%rip), %rax     # 0xf95c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiCharacterToName
char *apiCharacterToName( char *characterID )
{
    int i;
    static char w[ 256 ];

    strclr( w );
    for ( i = 0; i<API_MAXENTITIES; i++ )  {
        if ( 0 == strcmp( characterID, soldierTranslate[ i ].charID )) {
            strlcpy( w, soldierTranslate[ i ].playerName, 256 );
            break;
        }
    }
    return( w );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe3b7d(%rip), %rdi     # 0xf96c0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x15bb1
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
leaq 0xd3a4c(%rip), %rsi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x15ba4
movslq -0xc(%rbp), %rax
leaq 0xd3a2d(%rip), %rsi     # 0xe95b0
shlq $0x9, %rax
addq %rax, %rsi
addq $0x100, %rsi            # imm = 0x100
leaq 0xe3b28(%rip), %rdi     # 0xf96c0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x15bb1
jmp 0x15ba6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15b4f
leaq 0xe3b08(%rip), %rax     # 0xf96c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiIsPlayerAliveByName
int apiIsPlayerAliveByName( char *playerName )
{
    int isAlive = 1;

    if  ( apiBPIsActive() ) {
        if ( 0 == strlen( apiNameToCharacter( playerName ) ) )  {
            isAlive = 0;
        }
    }
    return( isAlive );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
callq 0x15420
cmpl $0x0, %eax
je 0x15c01
movq -0x8(%rbp), %rdi
callq 0x15aa0
movq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x15bff
movl $0x0, -0xc(%rbp)
jmp 0x15c01
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiIsPlayerAliveByGUID
int apiIsPlayerAliveByGUID( char *playerGUID )
{
    int isAlive = 1;
    char *playerName;

    if  ( apiBPIsActive() ) {
        playerName = rosterLookupNameFromGUID( playerGUID );       // returns empty if not found
        if ( 0 != strlen( playerName ) )  {
            if ( 0 == strlen( apiNameToCharacter( playerName )) )  {
                isAlive = 0;
            }
        }
    }
    return( isAlive );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
callq 0x15420
cmpl $0x0, %eax
je 0x15c73
movq -0x8(%rbp), %rdi
callq 0x1a150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x15c71
movq -0x18(%rbp), %rdi
callq 0x15aa0
movq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x15c6f
movl $0x0, -0xc(%rbp)
jmp 0x15c71
jmp 0x15c73
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiMapObjectiveCB
int _apiMapObjectiveCB( char *strIn )
{
    int i;
    char *w;

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

        if ( 0 == strlen( _objectiveListCache[i] )) {

            w = getWord( strIn, 1, "'" );
            if ( w != NULL ) {
                strlcpy( _objectiveListCache[i], w, API_LINE_STRING_MAX );
                logPrintf(LOG_LEVEL_INFO, "api", "Reading map objectives list ::%s:: index %d", _objectiveListCache[i], i );
            }
            break;

        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x15d40
movslq -0xc(%rbp), %rax
leaq 0xdb918(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x15d30
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xec7e(%rip), %rdx      # 0x2494c
callq 0x122d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15d2e
movslq -0xc(%rbp), %rax
leaq 0xdb8d7(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movslq -0xc(%rbp), %rax
leaq 0xdb8b7(%rip), %rcx     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rcx
movl -0xc(%rbp), %r8d
movl $0x2, %edi
leaq 0x10177(%rip), %rsi     # 0x25e97
leaq 0x10382(%rip), %rdx     # 0x260a9
movb $0x0, %al
callq 0x21bf0
jmp 0x15d40
jmp 0x15d32
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15c93
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiLookupObjectiveLetterFromCache
char apiLookupObjectiveLetterFromCache( char *objectiveName ) 
{
    char retChar = ' ';
    int i;

    for ( i = 0; i<API_OBJECTIVES_MAX; i++ ) {
       if ( 0 == strcmp( objectiveName, _objectiveListCache[i] )) {
           retChar = i + 'A';
           break;
       }
       if ( 0 == strlen( _objectiveListCache[i] )) {
           break;
       }
    }
    return retChar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x20, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jge 0x15dcb
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq 0xdb844(%rip), %rsi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x15d9b
movl -0x10(%rbp), %eax
addl $0x41, %eax
movb %al, -0x9(%rbp)
jmp 0x15dcb
movslq -0x10(%rbp), %rax
leaq 0xdb81a(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x15dbe
jmp 0x15dcb
jmp 0x15dc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15d67
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)