LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiLookupLastObjectiveLetterFromCache
char apiLookupLastObjectiveLetterFromCache( void )
{
    char retChar = ' ';
    int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x20, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jge 0x15e53
movslq -0x8(%rbp), %rax
leaq 0xdb7bc(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x15e23
movl -0x8(%rbp), %eax
addl $0x41, %eax
movb %al, -0x1(%rbp)
movslq -0x8(%rbp), %rax
leaq 0xdb792(%rip), %rdi     # 0xf15c0
shlq $0x8, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x15e46
jmp 0x15e53
jmp 0x15e48
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15df3
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiRoundStartCB
int _apiRoundStartCB( char  *strIn )
{
    int errCode;

    // 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", "RoundStart ActiveObjective update::%s:: and Error ::%d::", gameStatePrevious, errCode );

    // On new round clear the 'SISSM hot restart' flag.  
    //
    _inHotRestart = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x150d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %r8d
movl $0x2, %edi
leaq 0x10013(%rip), %rsi     # 0x25e97
leaq 0x1024a(%rip), %rdx     # 0x260d5
leaq 0xdf72e(%rip), %rcx     # 0xf55c0
movb $0x0, %al
callq 0x21bf0
movl $0x0, 0x1bc1d(%rip)     # 0x31ac0
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: apiCounterStartCB
int _apiCounterStartCB( char *strIn )
{
    // if ( NULL != strstr( strIn, "Advancing spawns for faction" ) ) {
    if ( NULL != strstr( strIn, "LogGameplayEvents: Display: Objective" ) ) {

        if ( NULL == strstr( strIn, "reset from" ) ) {    // exception case final obj breach

            _inCounterAttack = 1;

            // Take care of reverse or simultaneous reporting by NWI.
            // this happens when system decides to NOT issue counterattack
            //
            if (( apiTimeGet() - _inCounterTime ) < 3L ) {
                _inCounterAttack = 0;
            }
            logPrintf( LOG_LEVEL_INFO, "api", "In CounterAttack State '%s'", strIn );
        }

    }
    // logPrintf( LOG_LEVEL_INFO, "api", "StartCB - ACTIVITY '%s'", strIn );
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfe83(%rip), %rsi      # 0x2624a
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x16436
movq -0x8(%rbp), %rdi
leaq 0xfe8f(%rip), %rsi      # 0x26270
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x16434
movl $0x1, 0x146ac6(%rip)    # 0x15cec0
callq 0x150c0
subq 0x146ac2(%rip), %rax    # 0x15cec8
cmpq $0x3, %rax
jae 0x16416
movl $0x0, 0x146aaa(%rip)    # 0x15cec0
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0xfa71(%rip), %rsi      # 0x25e97
leaq 0xfe4e(%rip), %rdx      # 0x2627b
movb $0x0, %al
callq 0x21bf0
jmp 0x16436
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiCounterStopCB
int _apiCounterStopCB( char *strIn )
{
    _inCounterAttack = 0;
    _inCounterTime = apiTimeGet();  // EPOC resolution 1s
    logPrintf( LOG_LEVEL_INFO, "api", "Out of CounterAttack State '%s'", strIn );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0x146a6a(%rip)    # 0x15cec0
callq 0x150c0
movq %rax, 0x146a66(%rip)    # 0x15cec8
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0xfa25(%rip), %rsi      # 0x25e97
leaq 0xfe1e(%rip), %rdx      # 0x26297
movb $0x0, %al
callq 0x21bf0
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: apiServerRestart
int apiServerRestart( char *rebootReason )
{
    // Notify and force disconnect on all active players on roster
    //
    apiKickAll( rebootReason );
    sleep( 2 );    // wait for handshake
   
    // Save the reason & time for analytics and web 
    //
    strlcpy( lastRebootReason, rebootReason, 256 );
    lastRebootTime = apiTimeGet();
   
    // invoke system restart
    // 
    sissmServerRestart();
    lastRosterSuccessTime = apiTimeGet();      
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17570
movl $0x2, %edi
callq 0x8380
movq -0x8(%rbp), %rsi
leaq 0x14c4a6(%rip), %rdi    # 0x1639e0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
callq 0x150c0
movq %rax, 0x14c480(%rip)    # 0x1639d0
callq 0x8b30
callq 0x150c0
movq %rax, 0xc9f2f(%rip)     # 0xe1490
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiKickAll
int apiKickAll( char *reason )
{
    static char playerList[8192]; 
    char playerGUID[256], *p;
    int playerIndex = 0;

    strlcpy( playerList, rosterPlayerList( 5, ":" ), 8192 );

    // HAL9000 loop, kill all live humans
    //
    while ( 1 == 1 ) {

        if ( NULL == ( p = getWord( playerList, playerIndex++, ":" ) )) 
            break;

        strlcpy( playerGUID, p, 256 );
        apiKickOrBan(0, playerGUID, reason );
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0x11c(%rbp)
movl $0x5, %edi
leaq 0xe900(%rip), %rsi      # 0x25e95
callq 0x1a4b0
movq %rax, %rsi
leaq 0x16663c(%rip), %rdi    # 0x17dbe0
movl $0x2000, %edx           # imm = 0x2000
callq 0x11bc0
movl -0x11c(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
leaq 0x16661a(%rip), %rdi    # 0x17dbe0
leaq 0xe8c8(%rip), %rdx      # 0x25e95
callq 0x122d0
movq %rax, %rcx
movq %rcx, -0x118(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x175e5
jmp 0x17611
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x110(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %edi, %edi
callq 0x17cf0
jmp 0x175ae
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiTimeGetHuman
char *apiTimeGetHuman( unsigned long timeMark )
{
    static char humanTime[API_LINE_STRING_MAX];
    time_t current_time;

   
    if ( timeMark == 0L ) 
        current_time = time( NULL );
    else
        current_time = (time_t) timeMark;

    strlcpy( humanTime, ctime( &current_time ), API_LINE_STRING_MAX );

    return( humanTime );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17642
xorl %eax, %eax
movl %eax, %edi
callq 0x8280
movq %rax, -0x10(%rbp)
jmp 0x1764a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8100
movq %rax, %rsi
leaq 0x15c483(%rip), %rdi    # 0x173ae0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq 0x15c472(%rip), %rax    # 0x173ae0
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: apiGameModePropertyGet
char *apiGameModePropertyGet( char *gameModeProperty )
{
    static char value[16*1024];
    char rconCmd[API_T_BUFSIZE], rconResp[API_R_BUFSIZE], *w;
    int bytesRead, errCode;

    strclr( value );

    snprintf( rconCmd, API_T_BUFSIZE, "gamemodeproperty %s", gameModeProperty );
    if ( 0 == (errCode = rdrvCommand( _rPtr, 2, rconCmd, rconResp, &bytesRead ))) {
        if ( ((size_t) bytesRead) > strlen( gameModeProperty )) {
            // extract the value field.  This command will fail esp during
            // map change when rcon response is not honored, so check for this!
            w = getWord( rconResp, 1, "\"" );    
            if ( w != NULL ) 
                strlcpy( value, w, sizeof( value ));   
        }
    }

    return( value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
leaq 0x15c4aa(%rip), %rdi    # 0x173be0
callq 0x122b0
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0xece0(%rip), %rdx      # 0x26432
movb $0x0, %al
callq 0x8180
movq 0xc9d38(%rip), %rdi     # 0xe1498
leaq -0x1010(%rbp), %rdx
leaq -0x2010(%rbp), %rcx
movl $0x2, %esi
leaq -0x201c(%rbp), %r8
callq 0x9f20
movl %eax, %ecx
movl %ecx, -0x2020(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x177f8
movslq -0x201c(%rbp), %rax
movq %rax, -0x2028(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x2028(%rbp), %rax
cmpq %rcx, %rax
jbe 0x177f6
leaq -0x2010(%rbp), %rdi
movl $0x1, %esi
leaq 0xedf2(%rip), %rdx      # 0x265b8
callq 0x122d0
movq %rax, -0x2018(%rbp)
cmpq $0x0, -0x2018(%rbp)
je 0x177f4
movq -0x2018(%rbp), %rsi
leaq 0x15c3f6(%rip), %rdi    # 0x173be0
movl $0x4000, %edx           # imm = 0x4000
callq 0x11bc0
jmp 0x177f6
jmp 0x177f8
leaq 0x15c3e1(%rip), %rax    # 0x173be0
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiGameModePropertyGetRaw
char *apiGameModePropertyGetRaw( char *gameModeProperty )
{
    static char value[16*1024];
    char rconCmd[API_T_BUFSIZE], rconResp[API_R_BUFSIZE];
    int bytesRead, errCode;

    strclr( value );

    snprintf( rconCmd, API_T_BUFSIZE, "gamemodeproperty %s", gameModeProperty );
    if ( 0 == (errCode = rdrvCommand( _rPtr, 2, rconCmd, rconResp, &bytesRead ))) {
        if ( ((size_t) bytesRead) > strlen( gameModeProperty )) {
            strlcpy( value, rconResp, sizeof( value ));   
        }
    }
    return( value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
leaq 0x1603ba(%rip), %rdi    # 0x177be0
callq 0x122b0
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0xebf0(%rip), %rdx      # 0x26432
movb $0x0, %al
callq 0x8180
movq 0xc9c48(%rip), %rdi     # 0xe1498
leaq -0x1010(%rbp), %rdx
leaq -0x2010(%rbp), %rcx
movl $0x2, %esi
leaq -0x2014(%rbp), %r8
callq 0x9f20
movl %eax, %ecx
movl %ecx, -0x2018(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x178bd
movslq -0x2014(%rbp), %rax
movq %rax, -0x2020(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x2020(%rbp), %rax
cmpq %rcx, %rax
jbe 0x178bb
leaq -0x2010(%rbp), %rsi
leaq 0x16032f(%rip), %rdi    # 0x177be0
movl $0x4000, %edx           # imm = 0x4000
callq 0x11bc0
jmp 0x178bd
leaq 0x16031c(%rip), %rax    # 0x177be0
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiKick
int apiKick( char *playerNameOrGUID, char *reason )
{
    char rconCmd[API_T_BUFSIZE], rconResp[API_R_BUFSIZE];
    int bytesRead, errCode;

    // "stub" for dev testing - do not kick or ban
    //
    if ( 0L != p2pGetL( "dev.p2p.nokick", 0L )) {
        return 0;
    }

    // Process kick
    //
    snprintf( rconCmd, API_T_BUFSIZE, "kick \"%s\" \"%s\"", playerNameOrGUID, reason );
    errCode = rdrvCommand( _rPtr, 2, rconCmd, rconResp, &bytesRead );
    logPrintf( LOG_LEVEL_WARN, "api", "apiKick ::%s::", rconCmd );
 
    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xc863(%rip), %rdi      # 0x2475d
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x17f16
movl $0x0, -0x4(%rbp)
jmp 0x17f8e
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0xbd47(%rip), %rdx      # 0x23c78
movb $0x0, %al
callq 0x8180
movq 0xc9559(%rip), %rdi     # 0xe1498
leaq -0x1020(%rbp), %rdx
leaq -0x2020(%rbp), %rcx
movl $0x2, %esi
leaq -0x2024(%rbp), %r8
callq 0x9f20
movl %eax, -0x2028(%rbp)
leaq -0x1020(%rbp), %rcx
movl $0x1, %edi
leaq 0xdf20(%rip), %rsi      # 0x25e97
leaq 0xe533(%rip), %rdx      # 0x264b1
movb $0x0, %al
callq 0x21bf0
movl -0x2028(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiAuthIsAllowedCommand
int apiAuthIsAllowedCommand( char *playerGUID, char *command )
{
    int i, isAuthorized = 0;

    // check if playerGUID is 'root'
    //
    if ( NULL != strstr( rootguids, playerGUID )) {
        isAuthorized = 1;
    }
    
    // check if command is from 'RCON' if so grant 'root' priv
    //
    else if ( 0 == strcmp( "00000000000000000", playerGUID ) ) {
        isAuthorized = 1;
    }

    // check if command is for 'everyone'
    //
    else if ( NULL != strstr( everyoneCmds, command ))  {
        isAuthorized = 1;
    }

    // check the priv tables to see if guid-command pair is authorized
    //
    else {
        for (i=0; i<API_MAX_GROUPS; i++) {
            if ( NULL != strstr( groups[i].groupcmds, command )) {
                if ( apiIdListCheck( playerGUID, groups[i].groupIdList ) ) {
                    isAuthorized = 1;
                    break;
                }
            }
        }
    }

    // check if a player is solo, if so grant special privilege "soloadmin"
    //
    if ( !isAuthorized ) {
        if ( NULL != strstr( soloAdminCmds, command )) {
            if ( 1 == apiPlayersGetCount() ) {
                isAuthorized = 1;
            }
        }
    }
 
    return( isAuthorized );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xe147e(%rip), %rdi     # 0xf97c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1835d
movl $0x1, -0x18(%rbp)
jmp 0x1842b
movq -0x8(%rbp), %rsi
leaq 0xc38c(%rip), %rdi      # 0x246f4
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18381
movl $0x1, -0x18(%rbp)
jmp 0x18429
movq -0x10(%rbp), %rsi
leaq 0xe1634(%rip), %rdi     # 0xf99c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x183a7
movl $0x1, -0x18(%rbp)
jmp 0x18427
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x18425
movslq -0x14(%rbp), %rax
leaq 0xe2001(%rip), %rdi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rsi
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18418
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0xe1fce(%rip), %rsi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rsi
addq $0x700, %rsi            # imm = 0x700
callq 0x14ba0
cmpl $0x0, %eax
je 0x18416
movl $0x1, -0x18(%rbp)
jmp 0x18425
jmp 0x18418
jmp 0x1841a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x183ae
jmp 0x18427
jmp 0x18429
jmp 0x1842b
cmpl $0x0, -0x18(%rbp)
jne 0x18466
movq -0x10(%rbp), %rsi
leaq 0xe1a84(%rip), %rdi     # 0xf9ec0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18464
callq 0x17fe0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x18462
movl $0x1, -0x18(%rbp)
jmp 0x18464
jmp 0x18466
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiAuthIsAllowedMacro
int apiAuthIsAllowedMacro( char *playerGUID, char *command )
{
    int i, isAuthorized = 0;

    // check if playerGUID is 'root'
    //
    if ( NULL != strstr( rootguids, playerGUID )) {
        isAuthorized = 1;
    }

    // check if command is for 'RCON'
    //
    else if ( 0 == strcmp( "00000000000000000", playerGUID ) ) {
        isAuthorized = 1;
    }

    // check if command is for 'everyone'
    //
    else if ( NULL != strstr( everyoneMacros, command ))  {
        isAuthorized = 1;
    }

    // check the priv tables to see if guid-command pair is authorized
    //
    else {
        for (i=0; i<API_MAX_GROUPS; i++) {
            if ( NULL != strstr( groups[i].groupmacros, command )) {
                if ( apiIdListCheck( playerGUID, groups[i].groupIdList ) ) {
                    isAuthorized = 1;
                    break;
                }
            }
        }
    }

    // check if a player is solo, if so grant special privilege "soloadmin"
    //
    if ( !isAuthorized ) {
        if ( NULL != strstr( soloAdminMacros, command )) {
            if ( 1 == apiPlayersGetCount() ) {
                isAuthorized = 1;
            }
        }
    }
    return( isAuthorized );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xe132e(%rip), %rdi     # 0xf97c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x184ad
movl $0x1, -0x18(%rbp)
jmp 0x1857b
movq -0x8(%rbp), %rsi
leaq 0xc23c(%rip), %rdi      # 0x246f4
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x184d1
movl $0x1, -0x18(%rbp)
jmp 0x18579
movq -0x10(%rbp), %rsi
leaq 0xe16e4(%rip), %rdi     # 0xf9bc0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x184f7
movl $0x1, -0x18(%rbp)
jmp 0x18577
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x18575
movslq -0x14(%rbp), %rax
leaq 0xe1eb1(%rip), %rdi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rdi
addq $0x300, %rdi            # imm = 0x300
movq -0x10(%rbp), %rsi
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18568
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0xe1e7e(%rip), %rsi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rsi
addq $0x700, %rsi            # imm = 0x700
callq 0x14ba0
cmpl $0x0, %eax
je 0x18566
movl $0x1, -0x18(%rbp)
jmp 0x18575
jmp 0x18568
jmp 0x1856a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x184fe
jmp 0x18577
jmp 0x18579
jmp 0x1857b
cmpl $0x0, -0x18(%rbp)
jne 0x185b6
movq -0x10(%rbp), %rsi
leaq 0xe1b34(%rip), %rdi     # 0xfa0c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x185b4
callq 0x17fe0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x185b2
movl $0x1, -0x18(%rbp)
jmp 0x185b4
jmp 0x185b6
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiAuthIsAttribute
int apiAuthIsAttribute( char *playerGUID, char *attribute )
{
    int i, isAuthorized = 0;

    // check if playerGUID is 'root'
    //
    if ( NULL != strstr( rootguids, playerGUID )) {
        isAuthorized = 1;
    }
    else {
        for (i=0; i<API_MAX_GROUPS; i++) {
            if ( NULL != strstr( groups[i].groupattr, attribute)) {
                if ( apiIdListCheck( playerGUID, groups[i].groupIdList ) ) {
                    isAuthorized = 1;
                    break;
                }
            }
        }
    }
    // check if a player is solo, if so grant special privilege "soloadmin"
    //
    if ( !isAuthorized ) {
        if ( NULL != strstr( soloAdminAttr, attribute )) {
            if ( 1 == apiPlayersGetCount() ) {
                isAuthorized = 1;
            }
        }
    }
    return( isAuthorized );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xe11de(%rip), %rdi     # 0xf97c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x185fd
movl $0x1, -0x18(%rbp)
jmp 0x1867d
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x1867b
movslq -0x14(%rbp), %rax
leaq 0xe1dab(%rip), %rdi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rdi
addq $0x500, %rdi            # imm = 0x500
movq -0x10(%rbp), %rsi
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1866e
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0xe1d78(%rip), %rsi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rsi
addq $0x700, %rsi            # imm = 0x700
callq 0x14ba0
cmpl $0x0, %eax
je 0x1866c
movl $0x1, -0x18(%rbp)
jmp 0x1867b
jmp 0x1866e
jmp 0x18670
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18604
jmp 0x1867d
cmpl $0x0, -0x18(%rbp)
jne 0x186b8
movq -0x10(%rbp), %rsi
leaq 0xe1c32(%rip), %rdi     # 0xfa2c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x186b6
callq 0x17fe0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x186b4
movl $0x1, -0x18(%rbp)
jmp 0x186b6
jmp 0x186b8
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: apiAuthGetRank
char *apiAuthGetRank( char *playerGUID )
{
    static char rank[ 256 ];
    int i;

    // check if playerGUID is 'root'
    //
    strclr( rank );
    if ( NULL != strstr( rootguids, playerGUID )) {
        strlcpy( rank, rootname, 256 );
    }
    else {
        for (i=0; i<API_MAX_GROUPS; i++) {
            if ( apiIdListCheck( playerGUID, groups[i].groupIdList ) ) {
                strlcpy( rank, groups[i].groupname, 256 );
                break;
            }
        }
    }
    return( rank );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1674fd(%rip), %rdi    # 0x17fbe0
callq 0x122b0
movq -0x8(%rbp), %rsi
leaq 0xe10cd(%rip), %rdi     # 0xf97c0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1871c
leaq 0x1674d7(%rip), %rdi    # 0x17fbe0
leaq 0xe11b0(%rip), %rsi     # 0xf98c0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1878a
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x18788
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
leaq 0xe1c88(%rip), %rsi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rsi
addq $0x700, %rsi            # imm = 0x700
callq 0x14ba0
cmpl $0x0, %eax
je 0x1877b
movslq -0xc(%rbp), %rax
leaq 0xe1c62(%rip), %rsi     # 0xfa3c0
imulq $0x10700, %rax, %rax    # imm = 0x10700
addq %rax, %rsi
leaq 0x167471(%rip), %rdi    # 0x17fbe0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x18788
jmp 0x1877d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18723
jmp 0x1878a
leaq 0x16744f(%rip), %rax    # 0x17fbe0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiGetServerMode
char *apiGetServerMode( void )
{
    static char gameMode[256];
    int i;
    static char recognizedModes[16][64] = { 
        "hardcore",   "checkpoint", "frenzy",    "outpost",    "frontline", 
        "domination", "push",       "firefight", "deathmatch", "*" 
    };

    strlcpy( gameMode, "unknown", 256 );

    for ( i=0 ; ; i++ ) {
        if ( recognizedModes[i][0] == '*' ) break;
        if ( NULL != strcasestr( gameStatePrevious, recognizedModes[i] ) ) {
            strlcpy( gameMode, recognizedModes[i], 256 );
            break;
        }
    }
    return( gameMode );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x167501(%rip), %rdi    # 0x17fce0
leaq 0xdd2c(%rip), %rsi      # 0x26512
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x192ce(%rip), %rax     # 0x31ad0
shlq $0x6, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x18813
jmp 0x1886d
movslq -0x4(%rbp), %rax
leaq 0x192b2(%rip), %rsi     # 0x31ad0
shlq $0x6, %rax
addq %rax, %rsi
leaq 0xdcd94(%rip), %rdi     # 0xf55c0
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18860
movslq -0x4(%rbp), %rax
leaq 0x1928a(%rip), %rsi     # 0x31ad0
shlq $0x6, %rax
addq %rax, %rsi
leaq 0x16748c(%rip), %rdi    # 0x17fce0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1886d
jmp 0x18862
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x187f7
leaq 0x16746c(%rip), %rax    # 0x17fce0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiMapList
char *apiMapList( void )
{
    int j;
    static char mapList[4096];

    strclr( mapList );
    for ( j = 0; j<API_MAXMAPS; j++ ) {
        if ( 0 == strlen( mapNameMerged[j] ) ) break;
        strncat( mapList, mapNameMerged[j], 4095 );
        strncat( mapList, " ",              4095 );
    }
    return( mapList );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1f2661(%rip), %rdi    # 0x20aef0
callq 0x122b0
movl $0x0, -0x4(%rbp)
cmpl $0x200, -0x4(%rbp)      # imm = 0x200
jge 0x1890d
movslq -0x4(%rbp), %rax
leaq 0x1ed641(%rip), %rdi    # 0x205ef0
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x188c7
jmp 0x1890d
movslq -0x4(%rbp), %rax
leaq 0x1ed61e(%rip), %rsi    # 0x205ef0
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq 0x1f2610(%rip), %rdi    # 0x20aef0
movl $0xfff, %edx            # imm = 0xFFF
callq 0x81b0
leaq 0x1f25ff(%rip), %rdi    # 0x20aef0
leaq 0xb860(%rip), %rsi      # 0x24158
movl $0xfff, %edx            # imm = 0xFFF
callq 0x81b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1889b
leaq 0x1f25dc(%rip), %rax    # 0x20aef0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiIsSupportedGameMode
int apiIsSupportedGameMode( char *candidateMode  )
{
    int isGameMode = 0;
    int j;

    for ( j = 0; j<API_MAXMAPS; j++ ) {
        if ( 0 == strcasecmp( mapCycleList[j].gameMode, candidateMode ) ) {
            isGameMode = 1;
            break;
        }
    }
    return( isGameMode );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x200, -0x10(%rbp)     # imm = 0x200
jge 0x18986
movslq -0x10(%rbp), %rax
leaq 0x1675a2(%rip), %rdi    # 0x17fef0
imulq $0x430, %rax, %rax      # imm = 0x430
addq %rax, %rdi
addq $0x408, %rdi            # imm = 0x408
movq -0x8(%rbp), %rsi
callq 0x8040
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18979
movl $0x1, -0xc(%rbp)
jmp 0x18986
jmp 0x1897b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1893a
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiMutList
char *apiMutList( void )
{
    static char lineBuffer[ API_LINE_STRING_MAX ];
    int j = 0;
 
    strclr( lineBuffer );
    while ( 1 == 1 ) {
        if ( 0 == strlen( mutAllowedList[j] )) break;
        strlcat ( lineBuffer, mutAllowedList[j], API_LINE_STRING_MAX );
        strlcat ( lineBuffer, " ", API_LINE_STRING_MAX );
        j++;
    }
    strTrimInPlace( lineBuffer );
    return( lineBuffer );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x1f32da(%rip), %rdi    # 0x20bef0
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x1443aa(%rip), %rdi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x18c3e
jmp 0x18c84
movslq -0x4(%rbp), %rax
leaq 0x144387(%rip), %rsi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rsi
leaq 0x1f3299(%rip), %rdi    # 0x20bef0
movl $0x100, %edx            # imm = 0x100
callq 0x11aa0
leaq 0x1f3288(%rip), %rdi    # 0x20bef0
leaq 0xb4e9(%rip), %rsi      # 0x24158
movl $0x100, %edx            # imm = 0x100
callq 0x11aa0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18c1b
leaq 0x1f3265(%rip), %rdi    # 0x20bef0
callq 0x12450
leaq 0x1f3259(%rip), %rax    # 0x20bef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/api.c
// Function: apiMutLookup
int apiMutLookup( char *partialString, char *fullString, int maxStringSize )
{
    int j, returnCount = 0;

    // Clear the return string
    // 
    strclr( fullString );
    returnCount = 0;

    // Special exemption for 'none' which acts as a reset mutator
    //
    if ( 0 == strcasecmp( partialString, "none" ) ) {
        strlcpy( fullString, "none", maxStringSize );
        returnCount = 1;
    }
 
    // All other cases, search through the allowed mutator list for 
    // substring match.
    //
    else { 
    
        // Look for match and multiple-matches
        //
        j = 0;
        while ( 1 == 1 ) {
            if ( 0 == strlen( mutAllowedList[j] )) break;
           
            // Exact match has the highest prescedence
            // ignore all other substring matches
            // 
            if ( 0 == strcasecmp( mutAllowedList[j], partialString ) ) {
                strlcpy( fullString, mutAllowedList[j], maxStringSize );
                returnCount = 1;
                break;
            }

            // Substring match casee.  Count them in case there are more
            // than one matches.
            // 
            if ( NULL != strcasestr( mutAllowedList[j], partialString ) ) {
                strlcpy( fullString, mutAllowedList[j], maxStringSize );
                returnCount++;
            }
            j++;
        }
    }
    return returnCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x122b0
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd9e7(%rip), %rsi      # 0x266bc
callq 0x8040
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18d02
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
leaq 0xd9cb(%rip), %rsi      # 0x266bc
callq 0x11bc0
movl $0x1, -0x1c(%rbp)
jmp 0x18dd7
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
leaq 0x1442bc(%rip), %rdi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x18d2f
jmp 0x18dd5
movslq -0x18(%rbp), %rax
leaq 0x144296(%rip), %rdi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8040
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18d7a
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq 0x14426f(%rip), %rsi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
movl $0x1, -0x1c(%rbp)
jmp 0x18dd5
movslq -0x18(%rbp), %rax
leaq 0x14424b(%rip), %rdi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x18dc7
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq 0x144222(%rip), %rsi    # 0x15cfd0
imulq $0x50, %rax, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18d09
jmp 0x18dd7
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterIsValidGUID
int rosterIsValidGUID( char *testGUID )
{
    int i, isValid = 0;
    int len = (int) strlen( testGUID ); 
  
    switch ( len )  { 
    case IDSTEAMID64LEN:                // Steam
        isValid = 1;
        for (i=0; i<IDSTEAMID64LEN; i++) {
            if ( !isdigit( testGUID[i] )) {
                isValid = 0;
                break;
            }
        }
        break;
    case IDEPICIDLEN:                   // EPIC
        isValid = 2;
        for (i=0; i<IDEPICIDLEN; i++) {
            if ( ( !isxdigit( testGUID[i] )) && ( testGUID[i] != '|' ) ) {
                isValid = 0;
                break;
            }
        }
        break;
    case IDWINGDKLEN:                   // WinGDK
        isValid = 3;
        for (i=0; i<IDWINGDKLEN; i++) {
            if ( !isdigit( testGUID[i] )) {
                isValid = 0;
                break;
            }
        }
        break;
    default:
        isValid = 0;
    }

    return( isValid );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x10, %eax
je 0x1919d
jmp 0x190d0
movl -0x18(%rbp), %eax
subl $0x11, %eax
je 0x190e7
jmp 0x190da
movl -0x18(%rbp), %eax
subl $0x41, %eax
je 0x1913b
jmp 0x191ee
movl $0x1, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x11, -0xc(%rbp)
jge 0x19136
callq 0x83b0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x19129
movl $0x0, -0x10(%rbp)
jmp 0x19136
jmp 0x1912b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x190f5
jmp 0x191f5
movl $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x41, -0xc(%rbp)
jge 0x1919b
callq 0x83b0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x1918e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
je 0x1918e
movl $0x0, -0x10(%rbp)
jmp 0x1919b
jmp 0x19190
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19149
jmp 0x191f5
movl $0x3, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x191ec
callq 0x83b0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x191df
movl $0x0, -0x10(%rbp)
jmp 0x191ec
jmp 0x191e1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x191ab
jmp 0x191f5
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterFindFirstID
int rosterFindFirstID(  char *lineIn, char symOpen, char symClose, char *foundID, int maxString  )
{
    int lastOpen = -1, i, j, k, foundCode = 0;
    char testString[256];

    strclr( foundID );

    for ( i = 0; i < (int) strlen( lineIn ); i++ ) {

        if ( lineIn[i] == symOpen ) {
            lastOpen = i;
        }
        else if ( lineIn[i] == symClose ) {
            if ( lastOpen == -1 ) continue;

            // extract string between 'lastOpen' and 'i' and check
            //
            for ( j = lastOpen+1, k = 0; j<i; j++ ) {
                testString[ k++ ] = lineIn[ j ];
            }
            testString[ k ] = 0;

            // test the 'test string' -- if valid then exit as found
            //
            if ( 0 != ( foundCode = rosterIsValidGUID( testString )) ) {
                strlcpy( foundID, testString, maxString );
                break;
            }
        }
    }
    return( foundCode );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x134(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movl -0x134(%rbp), %eax
cmpl %ecx, %eax
jge 0x19334
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x19282
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x19324
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x19322
cmpl $-0x1, -0x20(%rbp)
jne 0x192a5
jmp 0x19326
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x192e7
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %cl
movl -0x2c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
cltq
movb %cl, -0x130(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x192b5
movslq -0x2c(%rbp), %rax
movb $0x0, -0x130(%rbp,%rax)
leaq -0x130(%rbp), %rdi
callq 0x190a0
movl %eax, %ecx
movl %ecx, -0x30(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x19320
movq -0x18(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x11bc0
jmp 0x19334
jmp 0x19322
jmp 0x19324
jmp 0x19326
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19240
movl -0x30(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterGetCoopSide
int rosterGetCoopSide( void )
{
    int retVal = -1;

    if ( NULL != strstr( rosterTravel, "Checkpoint_Security" ))   retVal = 0;
    if ( NULL != strstr( rosterTravel, "Checkpoint_Insurgents" )) retVal = 1;

    return( retVal );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x1f701a(%rip), %rdi    # 0x210480
leaq 0xd2af(%rip), %rsi      # 0x2671c
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x19483
movl $0x0, -0x4(%rbp)
leaq 0x1f6ff6(%rip), %rdi    # 0x210480
leaq 0xd29f(%rip), %rsi      # 0x26730
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x194a7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterGetLighting
char *rosterGetLighting( void )
{
    static char retStr[20];
    char *w, *v;

    // default return "day"
    strlcpy( retStr, "day", 20 );

    // find the "?lighting=" substring position 
    if ( NULL != (w = strstr( rosterTravel, MATCH_LIGHTING ) )) {
        // point to first letter after the "=" sign
        w += strlen( MATCH_LIGHTING );
        // parse the lighting parameter
        if ( NULL != (v = getWord( w, 0, "? " )) ) {
            strlcpy( retStr, v, 20 );
            strToLowerInPlace( retStr );
            strTrimInPlace( retStr );
        } 
    }
    return( retStr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1f70c1(%rip), %rdi    # 0x210580
leaq 0xd280(%rip), %rsi      # 0x26746
movl $0x14, %edx
callq 0x11bc0
leaq 0x1f6fa9(%rip), %rdi    # 0x210480
leaq 0xd26c(%rip), %rsi      # 0x2674a
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x8(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1954c
movq -0x8(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0xd24b(%rip), %rdx      # 0x26755
callq 0x122d0
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1954a
movq -0x10(%rbp), %rsi
leaq 0x1f7058(%rip), %rdi    # 0x210580
movl $0x14, %edx
callq 0x11bc0
leaq 0x1f7047(%rip), %rdi    # 0x210580
callq 0x12640
leaq 0x1f703b(%rip), %rdi    # 0x210580
callq 0x12450
jmp 0x1954c
leaq 0x1f702d(%rip), %rax    # 0x210580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterGetCoopObjectiveLetter
char rosterGetCoopObjectiveLetter( void )
{
    char retVal = ' ';
    char *w = NULL;

    strClean( rosterObjective );
    if ( NULL == (w = strstr( rosterObjective, "ODCheckpoint_" ) ) ) {
        if ( NULL == (w = strstr( rosterObjective, "OCCheckpoint_" ) ) )  {
            retVal = ' ';
        }
    }

    if ( w != NULL ) {
        retVal = w[ 13 ];  // extract 'A' from "OxCheckpoint_A_0"
    }

    // Third party maps do not necessarily follow the NWI objective convension.
    // This alternate lookup method uses dummp of objective name after map change
    // found in Insurgency.log file.
    //
    if ( retVal == ' ' ) {
        retVal = apiLookupObjectiveLetterFromCache( rosterObjective );
        logPrintf( LOG_LEVEL_INFO, "roster", "Using objective list cache and found objective letter ::%c:: from ::%s::", retVal, rosterObjective );
    }
    else {
        logPrintf( LOG_LEVEL_INFO, "roster", "Using parser and found objective letter ::%c::", retVal );
    }

    // At start of the server, the data from activeobjective seems unreliable.
    // This is a kluge to assume unreadable objective is 'A'
    //
    if ( retVal == ' ' ) {
        retVal = 'A';
        logPrintf( LOG_LEVEL_INFO, "roster", "Unnown Objective letter - Assuming ::%c::", retVal );
    }

    return( retVal );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x20, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x1f6c05(%rip), %rdi    # 0x210180
callq 0x12530
leaq 0x1f6bf9(%rip), %rdi    # 0x210180
leaq 0xd1ca(%rip), %rsi      # 0x26758
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x195c8
leaq 0x1f6bd8(%rip), %rdi    # 0x210180
leaq 0xd1b7(%rip), %rsi      # 0x26766
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x195c6
movb $0x20, -0x1(%rbp)
jmp 0x195c8
cmpq $0x0, -0x10(%rbp)
je 0x195d9
movq -0x10(%rbp), %rax
movb 0xd(%rax), %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0x19618
leaq 0x1f6b97(%rip), %rdi    # 0x210180
callq 0x15d50
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movl $0x2, %edi
leaq 0xd173(%rip), %rsi      # 0x26774
leaq 0xd173(%rip), %rdx      # 0x2677b
leaq 0x1f6b71(%rip), %r8     # 0x210180
movb $0x0, %al
callq 0x21bf0
jmp 0x19636
movsbl -0x1(%rbp), %ecx
movl $0x2, %edi
leaq 0xd14c(%rip), %rsi      # 0x26774
leaq 0xd195(%rip), %rdx      # 0x267c4
movb $0x0, %al
callq 0x21bf0
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0x19661
movb $0x41, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movl $0x2, %edi
leaq 0xd121(%rip), %rsi      # 0x26774
leaq 0xd199(%rip), %rdx      # 0x267f3
movb $0x0, %al
callq 0x21bf0
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterGetScenario
char *rosterGetScenario( void )
{
    char *pivot;
    static char nullString[2] = {0, 0};

    if (NULL == ( pivot = strstr( rosterTravel, "ProcessServerTravel: " ))) 
        pivot = nullString;
    else  
        pivot += strlen( "ProcesServerTravel: " );
    return( pivot );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1f6e01(%rip), %rdi    # 0x210480
leaq 0xd197(%rip), %rsi      # 0x2681d
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x8(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x196a6
leaq 0x1f6ef4(%rip), %rax    # 0x210594
movq %rax, -0x8(%rbp)
jmp 0x196b2
movq -0x8(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterGetMutator
char *rosterGetMutator( void )
{
    char *pivot;
    static char nullString[2] = {0, 0};

    if (NULL == ( pivot = strstr( rosterTravel, "?Mutators=" ))) 
        pivot = nullString;
    else  
        pivot += strlen( "?Mutators=" );
    return( pivot );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1f6db1(%rip), %rdi    # 0x210480
leaq 0xcf88(%rip), %rsi      # 0x2665e
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x8(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x196f6
leaq 0x1f6ea6(%rip), %rax    # 0x210596
movq %rax, -0x8(%rbp)
jmp 0x19702
movq -0x8(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterReset
void rosterReset( void )
{
    int i;

    for (i=0; i<ROSTER_MAX; i++) {
        strclr( masterRoster[i].netID );
        strclr( masterRoster[i].playerName );
        strclr( masterRoster[i].steamID );
        strclr( masterRoster[i].IPaddress );
        strclr( masterRoster[i].score );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x19815
movslq -0x4(%rbp), %rax
leaq 0x1f6f29(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x1f6f0f(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0x50, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x1f6ef1(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xa0, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x1f6ed0(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xf0, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x1f6eaf(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x122b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1975f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterInit
void rosterInit( void )
{
    strclr( rosterServerName    );
    strclr( rosterMapName       );
    strclr( rosterSessionID     );
    strclr( rosterObjective     );
    strclr( rosterObjectiveType );
    rosterReset();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f6d75(%rip), %rdi    # 0x2105a0
callq 0x122b0
leaq 0x1f6b49(%rip), %rdi    # 0x210380
callq 0x122b0
leaq 0x1f683d(%rip), %rdi    # 0x210080
callq 0x122b0
leaq 0x1f6931(%rip), %rdi    # 0x210180
callq 0x122b0
leaq 0x1f6a25(%rip), %rdi    # 0x210280
callq 0x122b0
callq 0x19750
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: tabDumpDebug
int tabDumpDebug( unsigned char *buf, int n )
{
    int i;
    char *headStr, *recdStr;

    headStr = strstr( (char * ) &buf[32], "========================" );         // start separator
    recdStr = &headStr[80];                                      // look for start of first record

    i = 0;
    while ( 1 == 1 ) {
        printf("::%s::\n", getWord( recdStr, i++, "\011"));
        if (i > 500) break;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq 0xcfa5(%rip), %rsi      # 0x26833
callq 0x8390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq 0xd196(%rip), %rdx      # 0x26a56
callq 0x122d0
movq %rax, %rsi
leaq 0xe116(%rip), %rdi      # 0x279e5
movb $0x0, %al
callq 0x8170
cmpl $0x1f4, -0x10(%rbp)     # imm = 0x1F4
jle 0x198e1
jmp 0x198e3
jmp 0x198aa
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)