LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushObjectSynth
int piantirushObjectSynth( char *strIn )
{
    alarmReset( dPtr, piantirushConfig.warnRusherDelaySec );

    // _startOfEverything();     
    // Handle condition for early territorial cap rushers [TRUSH]
    //  
    _capRusherClear();
    if ( NULL != strstr( rosterGetObjectiveType(), "Capturable" )) {
        alarmReset( tPtr, alarmStatus( aPtr ) );    // copy from cap rate "slow down" timer 
    }
    else {
        alarmCancel( tPtr );
    }

    // reset the variable that keeps track of peak# of "alive" player for this objective
    // leg.  This is used to track when to disarm auto-kick algorithm on LMS condition.
    //
    _peakAlivePlayer = -1;                // peak # of alive players on this objective leg
    kickArmed2 = 2;

    return 0;
}

// Assembly:
pushq %rbx
movq 0x2097d3(%rip), %rdi    # 0x21fe48
movslq 0x203e38(%rip), %rsi    # 0x21a4b4
callq 0xf953
callq 0x15ec8
callq 0x14246
leaq 0x8852(%rip), %rsi      # 0x1eee4
movq %rax, %rdi
callq 0x83b0
movq 0x2097af(%rip), %rbx    # 0x21fe50
testq %rax, %rax
je 0x166bf
movq 0x209273(%rip), %rdi    # 0x21f920
callq 0xf97e
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf953
jmp 0x166c7
movq %rbx, %rdi
callq 0xf974
movl $0xffffffff, 0x1380b(%rip) # imm = 0xFFFFFFFF
movl $0x2, 0x13805(%rip)     # 0x29ee0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushCacheDestroyed
int piantirushCacheDestroyed( char *strIn )
{
    char playerName[256], playerGUID[256], playerIP[256];

    rosterParseCacheDestroyed( strIn, 256, playerName, playerGUID, playerIP );
    // _localSay( "Cache destroyed by %s[%s]", playerName, playerGUID  );

    if ( piantirushConfig.autoKickEarlyDestruction ) {
        if ( ( _fastMode == 0 ) && ( alarmStatus( aPtr ) >= piantirushConfig.earlyDestroyTolerance )) {
            if ( kickArmed2 && kickArmed ) {
                // apiKickOrBan( 0, playerGUID, piantirushConfig.earlyDestroyKickMessage );
                if ( 0 == _localKickOrBan( 0, playerName, playerGUID, piantirushConfig.earlyDestroyKickMessage ) ) {
                    logPrintf( LOG_LEVEL_WARN, "piantirush", "%s[%s] Auto-kicked for early cache destruction", playerName, playerGUID );
                    _localSay( "'%s' auto-kicked for rushing", playerName );
                }
            }
        }
    }
    kickArmed = 0;

    if ( piantirushConfig.botSpawnKillWindowSec != 0L ) {      // if bot spawnkill prevension is enabled 
        alarmReset( sPtr, piantirushConfig.botSpawnKillWindowSec );           // set active window timer
        logPrintf( LOG_LEVEL_INFO, "piantirush", "Bot-spawnkill detection window open for %ld seconds", piantirushConfig.botSpawnKillWindowSec );
    }

    return 0;
}

// Assembly:
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
leaq 0x100(%rsp), %rdx
movq %rsp, %rcx
leaq 0x200(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0x14ee3
cmpl $0x0, 0x203dad(%rip)    # 0x21a4b8
je 0x16798
testb $0x1, 0x209754(%rip)    # 0x21fe6c
jne 0x16798
movq 0x2091ff(%rip), %rdi    # 0x21f920
callq 0xf97e
movslq 0x205193(%rip), %rcx    # 0x21b8c0
cmpq %rcx, %rax
jl 0x16798
cmpl $0x0, 0x137a7(%rip)     # 0x29ee0
je 0x16798
testb $0x1, 0x2096fe(%rip)    # 0x21fe40
je 0x16798
leaq 0x204975(%rip), %rdx    # 0x21b0c0
leaq 0x100(%rsp), %rdi
movq %rsp, %rsi
callq 0x167e2
testl %eax, %eax
jne 0x16798
leaq 0x8384(%rip), %rsi      # 0x1eaea
leaq 0x848f(%rip), %rdx      # 0x1ebfc
leaq 0x100(%rsp), %rbx
movq %rsp, %r8
movl $0x1, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a227
leaq 0x849d(%rip), %rdi      # 0x1ec2b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x16554
movb $0x0, 0x2096a1(%rip)    # 0x21fe40
movslq 0x207966(%rip), %rsi    # 0x21e10c
testq %rsi, %rsi
je 0x167d7
movq 0x209686(%rip), %rdi    # 0x21fe38
callq 0xf953
movl 0x20794f(%rip), %ecx    # 0x21e10c
leaq 0x8326(%rip), %rsi      # 0x1eaea
leaq 0x847d(%rip), %rdx      # 0x1ec48
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: localKickOrBan
static int _localKickOrBan( int isBan, char *optionalPlayerName, char *playerGUID, char *reason )
{
    int errCode = 0, notKicked = 0;
    char *v;
    long autoKickExemptSecsL;

    // nonzero value here means protection window is set for non-kick. The
    // value is countdown timer in seconds, stops at 0L.
    //
    autoKickExemptSecsL = p2pGetL( "piantirush.p2p.nokickprotect", 0L );

    // a wedge code to disable this plugin if non-Checkpoint mode is running
    //
    v = apiGetServerMode();
    if (! ((0==strcmp( v, "checkpoint" )) || (0==strcmp( v, "hardcore"))) )  return 0;

    if ( 0L == autoKickExemptSecsL ) {

        // this will kick a player "for reals"
        //
        if (0 != strlen( playerGUID )) 
            errCode |= apiKickOrBan( isBan, playerGUID, reason );

        // redundancy
        //
        if ( 0 != strlen( optionalPlayerName )) 
            errCode |= apiKick( optionalPlayerName, reason );

        logPrintf( LOG_LEVEL_DEBUG, "piantirush", "Rush-AutoKick ::%s::%s::", playerGUID, optionalPlayerName );
    }
    else {
        notKicked = 1;
        logPrintf( LOG_LEVEL_INFO, "piantirush", "Rush-AutoKick Exempted by Admin ::%s::%s::", playerGUID, optionalPlayerName );
    }

    return( notKicked );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5777(%rip), %rdi      # 0x1bf74
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x18004
movq %rax, %r13
callq 0x13a76
movq %rax, %rbp
leaq 0x67c2(%rip), %rsi      # 0x1cfdb
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x16838
leaq 0x57d3(%rip), %rsi      # 0x1bfff
movq %rbp, %rdi
callq 0x8220
testl %eax, %eax
jne 0x168ab
testq %r13, %r13
je 0x16865
leaq 0x82a6(%rip), %rsi      # 0x1eaea
leaq 0x8ffa(%rip), %rdx      # 0x1f845
movl $0x2, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1a227
movl $0x1, %r12d
jmp 0x168ab
cmpb $0x0, (%r14)
je 0x16878
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x132ff
cmpb $0x0, (%rbx)
je 0x16888
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13412
leaq 0x825b(%rip), %rsi      # 0x1eaea
leaq 0x8f96(%rip), %rdx      # 0x1f82c
xorl %r12d, %r12d
movl $0x3, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1a227
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushObjUntouchCB
int piantirushObjUntouchCB( char *strIn )
{
    char *w, *n, m[64];
    char charID[64], tmpCharID[64], playerName[64]; 

    // First check if the time is within the territory  protection window zone (i.e., "too early")
    //
    if ( alarmStatus( tPtr ) > 5 ) {

        //  Get charcter ID
        //
        if ( NULL != (w = strstr( strIn, "BP_Character_Player" )) ) {
            strlcpy( tmpCharID, w, 64 );
            if ( NULL != (n = getWord( tmpCharID, 0, ". " ) )) {
                strlcpy( charID, n, 64 );
                if ( NULL != strstr( strIn, rosterGetObjective() )) {
                    // Convert Character ID to player Name
                    //
                    strlcpy(m, apiCharacterToName( charID ), 64 );
                    if ( 0 != strlen( m )) {
                        strlcpy( playerName, m, 64 );
                        if ( kickArmed2 && kickArmed ) _localSayThrottled( "'%s' %s", playerName, piantirushConfig.earlyBreachExit );
                        _capRusherExitZone( charID );
                    }
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq 0x209029(%rip), %rdi    # 0x21fe50
callq 0xf97e
cmpq $0x6, %rax
jl 0x16f98
leaq 0x719d(%rip), %rsi      # 0x1dfda
movq %rbx, %rdi
callq 0x83b0
testq %rax, %rax
je 0x16f98
leaq 0xc0(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xf038
leaq 0x7e0f(%rip), %rdx      # 0x1ec7c
movq %r14, %rdi
xorl %esi, %esi
callq 0xf4e1
testq %rax, %rax
je 0x16f98
movq %rsp, %rdi
movl $0x40, %edx
movq %rax, %rsi
callq 0xf038
callq 0x1423e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x83b0
testq %rax, %rax
je 0x16f98
movq %rsp, %rdi
callq 0x11b1b
leaq 0x80(%rsp), %rbx
movl $0x40, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf038
cmpb $0x0, (%rbx)
je 0x16f98
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl $0x40, %edx
callq 0xf038
cmpl $0x0, 0x12ff0(%rip)     # 0x29ee0
je 0x16f0e
testb $0x1, 0x208f47(%rip)    # 0x21fe40
je 0x16f0e
leaq 0x2061d6(%rip), %rdx    # 0x21d0d8
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x16c5e
leaq 0x208f7b(%rip), %rbx    # 0x21fe90
xorl %r15d, %r15d
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0x16f40
incq %r15
addq $0x8c, %rbx
cmpq $0x40, %r15
jne 0x16f1b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x16f81
movslq %r15d, %rax
imulq $0x8c, %rax, %rax
leaq 0x208f39(%rip), %rcx    # 0x21fe90
movl $0x0, 0x88(%rax,%rcx)
leaq 0x7b81(%rip), %rsi      # 0x1eaea
leaq 0x8951(%rip), %rdx      # 0x1f8c1
movq %rsp, %rcx
movl $0x3, %edi
xorl %eax, %eax
callq 0x1a227
jmp 0x16f98
leaq 0x7b62(%rip), %rsi      # 0x1eaea
leaq 0x8951(%rip), %rdx      # 0x1f8e0
xorl %edi, %edi
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: normalSpeedAlarmCB
static int _normalSpeedAlarmCB( char *str )
{
    _captureSpeedForceNext();
    _captureSpeed( 0 );
    _captureSpeedForceNext();
    logPrintf( LOG_LEVEL_DEBUG, "piantirush", "Antirush NORMAL alarm triggered" );
    kickArmed = 0;                    // kick safety : disable kick
  
    return 0;
}

// Assembly:
pushq %rbx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, 0x1242d(%rip)     # 0x29ee4
xorl %edi, %edi
callq 0x15a74
movl %ebx, 0x12420(%rip)     # 0x29ee4
leaq 0x701f(%rip), %rsi      # 0x1eaea
leaq 0x7e5b(%rip), %rdx      # 0x1f92d
movl $0x3, %edi
xorl %eax, %eax
callq 0x1a227
movb $0x0, 0x20835b(%rip)    # 0x21fe40
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: rulesAlarmCB
static int _rulesAlarmCB( char *str )
{
    char *typeObj;
    char outStr[256];

    strclr( outStr );

    // Determine if the next objective is destructible or capturable.  Send out a different
    // warning depending on the objective type.
    // 
    typeObj = rosterGetObjectiveType();
    if ( NULL != strcasestr( typeObj, "weaponcache" ) ) {
        strlcpy( outStr, piantirushConfig.warnRusherDestructible, 256 ); 
    }
    if ( NULL != strcasestr( typeObj, "capturable"  ) ) {
        strlcpy( outStr, piantirushConfig.warnRusherCapturable,   256 );
    }

    _localSay( outStr );
    if ( 0 != strlen( outStr )) kickArmed = 1;                       // kick safety : enable kick

    if (_fastMode) kickArmed = 0;                   // exception: in fast mode, do not kick anyone

    return 0;
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsp, %rdi
callq 0xf4dd
callq 0x14246
movq %rax, %rbx
leaq 0x43d2(%rip), %rsi      # 0x1beda
movq %rax, %rdi
callq 0x8350
testq %rax, %rax
je 0x17b29
leaq 0x202598(%rip), %rsi    # 0x21a0b4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
leaq 0x43b6(%rip), %rsi      # 0x1bee6
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0x17b51
leaq 0x202170(%rip), %rsi    # 0x219cb4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x16554
cmpb $0x0, (%rbx)
je 0x17b6a
movb $0x1, 0x2082d6(%rip)    # 0x21fe40
cmpb $0x1, 0x2082fb(%rip)    # 0x21fe6c
jne 0x17b7a
movb $0x0, 0x2082c6(%rip)    # 0x21fe40
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: notifyNoDestroyCB
static int _notifyNoDestroyCB( char *str ) 
{
    if (piantirushConfig.autoKickEarlyDestruction) {
        if ( NULL != strstr( rosterGetObjectiveType(), "WeaponCache" ))  {
            _localSay( piantirushConfig.destroyHoldPrompt );
        }
    }
    return 0;
}

// Assembly:
cmpl $0x0, 0x20292c(%rip)    # 0x21a4b8
je 0x17bba
pushq %rax
callq 0x14246
leaq 0x6fa8(%rip), %rsi      # 0x1eb43
movq %rax, %rdi
callq 0x83b0
testq %rax, %rax
je 0x17bb6
leaq 0x203111(%rip), %rdi    # 0x21acc0
xorl %eax, %eax
callq 0x16554
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: earlyDestroyReqCB
static int _earlyDestroyReqCB( char *str )
{
    if ( !_isQuiet() && ( 0L != p2pGetL( "piantirush.p2p.training", 0L )) ) {  // if not quiet & training is 'on'
        _localSay( piantirushConfig.teamNotReadyPrompt );
    }
    else if ( alarmStatus( aPtr ) < (long) (piantirushConfig.destroySpeedup + piantirushConfig.trEarDesOfs) ) {
        _localSay( piantirushConfig.destroyOkPrompt );
        kickArmed = 0;                    // kick safety : disable kick
        alarmCancel( aPtr );
        _captureSpeed( 0 );  
    }
    else {
        _localSay( piantirushConfig.destroyDenyPrompt );
    }
    return 0;
}

// Assembly:
pushq %rax
callq 0x17d42
testl %eax, %eax
je 0x17c1c
movq 0x207d52(%rip), %rdi    # 0x21f920
callq 0xf97e
movslq 0x2028e2(%rip), %rcx    # 0x21a4bc
movslq 0x205d17(%rip), %rdx    # 0x21d8f8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x17c13
leaq 0x2028d0(%rip), %rdi    # 0x21a4c0
xorl %eax, %eax
callq 0x16554
movb $0x0, 0x208242(%rip)    # 0x21fe40
movq 0x207d1b(%rip), %rdi    # 0x21f920
callq 0xf974
xorl %edi, %edi
callq 0x15a74
jmp 0x17c3d
leaq 0x202ca6(%rip), %rdi    # 0x21a8c0
jmp 0x17c36
leaq 0x3cef(%rip), %rdi      # 0x1b912
xorl %esi, %esi
callq 0x18004
testq %rax, %rax
je 0x17bc7
leaq 0x2060ce(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x16554
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: earlyBreachReqCB
static int _earlyBreachReqCB( char *str )
{
    if ( !_isQuiet() && ( 0L != p2pGetL( "piantirush.p2p.training", 0L )) ) {  // if not quiet & training is 'on'
        _localSay( piantirushConfig.teamNotReadyPrompt );
    }
    else if ( alarmStatus( aPtr ) < (long) piantirushConfig.earlyBreachSpeedup + piantirushConfig.trEarlyOfs ) {
        _localSay( piantirushConfig.breachOkPrompt );
        alarmReset( aPtr, 2L );   
        _capRusherClear();
        // _captureSpeed( 0 );   
    }
    else {
        _localSay( piantirushConfig.breachDenyPrompt );
    }
    return 0;
}

// Assembly:
pushq %rax
callq 0x17d42
testl %eax, %eax
je 0x17c9f
movq 0x207ccb(%rip), %rdi    # 0x21f920
callq 0xf97e
movslq 0x20446b(%rip), %rcx    # 0x21c0cc
movslq 0x205c88(%rip), %rdx    # 0x21d8f0
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x17c96
leaq 0x203c55(%rip), %rdi    # 0x21b8cc
xorl %eax, %eax
callq 0x16554
movq 0x207c9b(%rip), %rdi    # 0x21f920
movl $0x2, %esi
callq 0xf953
callq 0x15ec8
jmp 0x17cc0
leaq 0x20402f(%rip), %rdi    # 0x21bccc
jmp 0x17cb9
leaq 0x3c6c(%rip), %rdi      # 0x1b912
xorl %esi, %esi
callq 0x18004
testq %rax, %rax
je 0x17c4e
leaq 0x20604b(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x16554
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piantirush.c
// Function: isQuiet
static int _isQuiet( void )
{
    int quietState = 0;

    // Check if the feature is diabled - if so it's always 'quiet'
    // 
    if ( piantirushConfig.minimumQuietTimeSec == 0 ) 
        quietState = 1;
 
    // Check if field has been quiet for 'minimumQuietTime' seconds.
    //
    else if ( _lastKillTime +  piantirushConfig.minimumQuietTimeSec <= apiTimeGet() ) 
        quietState = 1;

    // Check if the server just started (initial exception case)
    //
    else if ( _lastKillTime == 0L ) 
        quietState = 1;

    return( quietState );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x2063bb(%rip), %r14    # 0x21e108
movl $0x1, %ebx
testq %r14, %r14
je 0x17d75
addq 0x2080d2(%rip), %r14    # 0x21fe30
callq 0x114b2
cmpq %rax, %r14
jbe 0x17d75
xorl %ebx, %ebx
cmpq $0x0, 0x2080be(%rip)    # 0x21fe30
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pSearch
static int _p2pSearch( char *varName, int autoCreate )
{
    int foundIndex = -1;
    int i;
    for (i=0; i<P2P_MAXELEM; i++) {
        if ( 0 == strcmp( varName, p2pVarNames[i] ) ) {
            foundIndex = i;
            break;
        }
    }

    if (( -1 == foundIndex ) && autoCreate ) {
        for (i=0; i<P2P_MAXELEM; i++) {
            if ( 0 == strlen( p2pVarNames[i] ) ) {
                strlcpy( p2pVarNames[i], varName, P2P_MAXSTR );
                strclr( p2pVarValues[i] );
                foundIndex = i;
                break;
            }
        }
        if ( -1 == foundIndex ) {
            logPrintf( LOG_LEVEL_CRITICAL, "p2p", "ERROR: Out of space");
        }
    }
    return( foundIndex );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20cb93(%rip), %r15    # 0x224990
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x17e23
incq %rbx
subq $-0x80, %r15
cmpq $0x100, %rbx            # imm = 0x100
jne 0x17dff
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebx
setne %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x17e9b
leaq 0x214b57(%rip), %r15    # 0x22c990
leaq 0x20cb50(%rip), %rdi    # 0x224990
xorl %ebx, %ebx
movl $0x80, %eax
cmpb $0x0, (%rdi)
je 0x17e65
incq %rbx
addq %rax, %r15
addq %rax, %rdi
cmpq $0x100, %rbx            # imm = 0x100
jne 0x17e47
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x17e7a
movl $0x80, %edx
movq %r14, %rsi
callq 0xf038
movq %r15, %rdi
callq 0xf4dd
cmpl $-0x1, %ebx
jne 0x17e9b
leaq 0x7b7a(%rip), %rsi      # 0x1fa00
leaq 0x7b77(%rip), %rdx      # 0x1fa04
xorl %edi, %edi
xorl %eax, %eax
callq 0x1a227
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pGetF
double p2pGetF( char *varName, double defaultValue )
{
    int i;
    double retValue = defaultValue;

    if ( -1 != (i = _p2pSearch( varName, 0 )) ) {
        if ( 0 == strlen( p2pVarValues[i] )) 
            retValue = defaultValue;
        if ( 1 != sscanf( p2pVarValues[i], "%lf", &retValue ) )
            retValue = defaultValue;
    }
    return( retValue );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x20ca0d(%rip), %r14    # 0x224990
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8220
testl %eax, %eax
je 0x17fab
incq %r15
subq $-0x80, %r14
cmpq $0x100, %r15            # imm = 0x100
jne 0x17f86
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x17ff5
movslq %r15d, %rax
shlq $0x7, %rax
leaq 0x2149d1(%rip), %rcx    # 0x22c990
leaq (%rcx,%rax), %rdi
cmpb $0x0, (%rax,%rcx)
jne 0x17fd4
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x50e5(%rip), %rsi      # 0x1d0c0
movq %rsp, %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
je 0x17ff5
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pGetL
unsigned long p2pGetL( char *varName, unsigned long defaultValue )
{
    int i;
    unsigned long retValue = defaultValue;

    if ( -1 != (i = _p2pSearch( varName, 0 )) ) {
        if ( 0 == strlen( p2pVarValues[i] )) 
            retValue = defaultValue;
        else if ( 1 != sscanf( p2pVarValues[i], "%lu", &retValue ) ) 
            retValue = defaultValue;
    }
    return( retValue );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
leaq 0x20c973(%rip), %r15    # 0x224990
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x18045
incq %r12
subq $-0x80, %r15
cmpq $0x100, %r12            # imm = 0x100
jne 0x18020
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
je 0x1807c
movslq %r12d, %rax
shlq $0x7, %rax
leaq 0x214937(%rip), %rdi    # 0x22c990
cmpb $0x0, (%rax,%rdi)
je 0x18078
addq %rax, %rdi
leaq 0x7937(%rip), %rsi      # 0x1f9a0
movq %rsp, %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
je 0x1807c
movq %rbx, (%rsp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pGetS
char  *p2pGetS( char *varName, char *defaultValue )
{
    int i;
    static char retValue[ P2P_MAXSTR ];

    if ( -1 != (i = _p2pSearch( varName, 0 )) ) 
        strlcpy( retValue, p2pVarValues[i], P2P_MAXSTR );
    else 
        strlcpy( retValue, defaultValue, P2P_MAXSTR );
     return( retValue );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20c8ef(%rip), %r15    # 0x224990
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x180c9
incq %r12
subq $-0x80, %r15
cmpq $0x100, %r12            # imm = 0x100
jne 0x180a4
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movslq %r12d, %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq 0x2148b6(%rip), %rsi    # 0x22c990
addq %rcx, %rsi
cmpl $-0x1, %eax
cmoveq %rbx, %rsi
leaq 0x21c8a5(%rip), %rbx    # 0x234990
movl $0x80, %edx
movq %rbx, %rdi
callq 0xf038
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pTestMain
int p2pTestMain()
{
    p2pInit();

    p2pSetS( "test123", "string1" );
    p2pSetS( "test123", "string2" );
    p2pSetS( "test123", "string3" );
    p2pSetS( "test123", "string123" );
    printf("\n::%s::\n", p2pGetS( "test123", "default" ));

    p2pSetF( "test3210", 3.141 );
    p2pSetF( "test3210", 3.142 );
    p2pSetF( "test3210", 3.143 );
    p2pSetF( "test3210", 3.14 );
    printf("\n::%lf::\n", p2pGetF( "test321", 2.17 ));

    p2pDebugDump();

    return 0;
}

// Assembly:
pushq %rbx
callq 0x18107
leaq 0x7808(%rip), %rbx      # 0x1f9b2
leaq 0x7809(%rip), %rsi      # 0x1f9ba
movq %rbx, %rdi
callq 0x17f0b
leaq 0x7802(%rip), %rsi      # 0x1f9c2
movq %rbx, %rdi
callq 0x17f0b
leaq 0x77fb(%rip), %rsi      # 0x1f9ca
movq %rbx, %rdi
callq 0x17f0b
leaq 0x77f4(%rip), %rsi      # 0x1f9d2
movq %rbx, %rdi
callq 0x17f0b
leaq 0x857a(%rip), %rsi      # 0x20767
movq %rbx, %rdi
callq 0x1808c
leaq 0x77e0(%rip), %rdi      # 0x1f9dc
leaq 0x21c78d(%rip), %rsi    # 0x234990
xorl %eax, %eax
callq 0x8180
leaq 0x77d4(%rip), %rbx      # 0x1f9e5
movsd 0x775f(%rip), %xmm0     # 0x1f978
movq %rbx, %rdi
callq 0x17d80
movsd 0x7757(%rip), %xmm0     # 0x1f980
movq %rbx, %rdi
callq 0x17d80
movsd 0x774f(%rip), %xmm0     # 0x1f988
movq %rbx, %rdi
callq 0x17d80
movsd 0x7747(%rip), %xmm0     # 0x1f990
movq %rbx, %rdi
callq 0x17d80
leaq 0x77a0(%rip), %rdi      # 0x1f9f8
movsd 0x7738(%rip), %xmm0     # 0x1f998
callq 0x17f65
leaq 0x7782(%rip), %rdi      # 0x1f9ee
movb $0x1, %al
callq 0x8180
callq 0x18141
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001InitConfig
int pit001InitConfig( void )
{
    cfsPtr cP;

    cP = cfsCreate( sissmGetConfigPath() );

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

    // read "pit001.StringParameterExample" variable from the .cfg file
    strlcpy( pit001Config.stringParameterExample,  cfsFetchStr( cP, "pit001.StringParameterExample",  "game starting!" ), CFS_FETCH_MAX);
    strlcpy( pit001Config.stringParameterExample2, cfsFetchStr( cP, "pit001.StringParameterExample2", "round starting!" ), CFS_FETCH_MAX);
    strlcpy( pit001Config.stringParameterExample3, cfsFetchStr( cP, "pit001.StringParameterExample3", "to the next objective!" ), CFS_FETCH_MAX);

    // read "pit001.NumericParameterExample" variable from the .cfg file
    pit001Config.numericParameterExample = (int) cfsFetchNum( cP, "pit001.NumericParameterExample", 3.1415926 );

    cfsDestroy( cP );
    return 0;
}

// Assembly:
pushq %rbx
callq 0x8969
movq %rax, %rdi
callq 0x9004
movq %rax, %rbx
leaq 0x77ac(%rip), %rsi      # 0x1fa40
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x21c766(%rip)    # 0x234a10
leaq 0x77a2(%rip), %rsi      # 0x1fa53
leaq 0x77b9(%rip), %rdx      # 0x1fa71
movq %rbx, %rdi
callq 0x907b
leaq 0x21c74d(%rip), %rdi    # 0x234a14
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x77a5(%rip), %rsi      # 0x1fa80
leaq 0x77bd(%rip), %rdx      # 0x1fa9f
movq %rbx, %rdi
callq 0x907b
leaq 0x21cb23(%rip), %rdi    # 0x234e14
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x77aa(%rip), %rsi      # 0x1faaf
leaq 0x77c2(%rip), %rdx      # 0x1face
movq %rbx, %rdi
callq 0x907b
leaq 0x21cef9(%rip), %rdi    # 0x235214
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x77b6(%rip), %rsi      # 0x1fae5
movsd 0x76e1(%rip), %xmm0     # 0x1fa18
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x21d2cb(%rip)    # 0x235614
movq %rbx, %rdi
callq 0x905c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001ClientAddCB
int pit001ClientAddCB( char *strIn )
{
    char playerName[256], playerGUID[256], playerIP[256];

    rosterParsePlayerConn( strIn, 256, playerName, playerGUID, playerIP );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Add Client ::%s::%s::%s::", playerName, playerGUID, playerIP );

    if ( apiPlayersGetCount() >= 8 ) {   // if the last connect player is #8 (last slot if 8 port server)
        if ( 0 != strcmp(playerGUID, "76561000000000000" )) {    // check if this is the server owner 
	    apiKickOrBan( 0, playerGUID, "Sorry the last port reserved for server owner only" );
            apiSay ( "pit001: Player %s kicked server full", playerName );
	}
        apiSay ( "pit001: Welcome server owner %s", playerName );
    }
    else {
        apiSay ( "pit001: Welcome %s", playerName );
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
leaq 0x100(%rsp), %rbx
movq %rsp, %r14
leaq 0x200(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x15182
leaq 0x7776(%rip), %rsi      # 0x1fb04
leaq 0x7fed(%rip), %rdx      # 0x20382
movl $0x2, %edi
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1a227
callq 0x134dc
cmpl $0x8, %eax
jl 0x18411
movdqa (%rsp), %xmm0
movzwl 0x10(%rsp), %eax
movd %eax, %xmm1
pcmpeqb 0x7656(%rip), %xmm0     # 0x1fa20
pcmpeqb 0x765e(%rip), %xmm1     # 0x1fa30
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
leaq 0x7794(%rip), %rbx      # 0x1fb75
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x18418
leaq 0x772e(%rip), %rdx      # 0x1fb1d
movq %rsp, %rsi
xorl %edi, %edi
callq 0x132ff
leaq 0x7750(%rip), %rdi      # 0x1fb50
leaq 0x100(%rsp), %rsi
xorl %eax, %eax
callq 0x12fba
jmp 0x18418
leaq 0x777d(%rip), %rbx      # 0x1fb95
leaq 0x100(%rsp), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001ClientDelCB
int pit001ClientDelCB( char *strIn )
{
    char playerName[256], playerGUID[256], playerIP[256];

    rosterParsePlayerDisConn( strIn, 256, playerName, playerGUID, playerIP );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Del Client ::%s::%s::%s::", playerName, playerGUID, playerIP );

    apiSay ( "pit001: Good bye %s", playerName );

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
leaq 0x200(%rsp), %rbx
leaq 0x100(%rsp), %r14
movq %rsp, %r15
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x1520e
leaq 0x7692(%rip), %rsi      # 0x1fb04
leaq 0x772f(%rip), %rdx      # 0x1fba8
movl $0x2, %edi
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1a227
leaq 0x772d(%rip), %rdi      # 0x1fbc2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001MapChangeCB
int pit001MapChangeCB( char *strIn )
{
    char mapName[256];

    logPrintf( LOG_LEVEL_INFO, "pit001", "Map Change Event ::%s::", strIn );
    rosterParseMapname( strIn, 256, mapName );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Map name ::%s::", mapName );
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq 0x75fc(%rip), %r14      # 0x1fb04
leaq 0x76ee(%rip), %rdx      # 0x1fbfd
movl $0x2, %edi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a227
movq %rsp, %r15
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0x15487
leaq 0x76da(%rip), %rdx      # 0x1fc15
movl $0x2, %edi
movq %r14, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001GameStartCB
int pit001GameStartCB( char *strIn )
{
    char newCount[256];

    logPrintf( LOG_LEVEL_INFO, "pit001", "Game Start Event ::%s::", strIn );

    apiGameModePropertySet( "minimumenemies", "4" );
    apiGameModePropertySet( "maximumenemies", "4" );

    strlcpy( newCount, apiGameModePropertyGet( "minimumenemies" ), 256) ;

    // in-game announcement start of game
    apiSay( "pit001: %s -- 2 waves of %s bots", pit001Config.stringParameterExample, newCount );  

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rcx
leaq 0x7594(%rip), %rsi      # 0x1fb04
leaq 0x76ae(%rip), %rdx      # 0x1fc25
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
leaq 0x34b9(%rip), %rbx      # 0x1ba43
leaq 0x719e(%rip), %r14      # 0x1f72f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e70
leaq 0x34af(%rip), %rdi      # 0x1ba52
movq %r14, %rsi
callq 0x12e70
movq %rbx, %rdi
callq 0x12e75
movq %rsp, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf038
leaq 0x7670(%rip), %rdi      # 0x1fc3d
leaq 0x21c440(%rip), %rsi    # 0x234a14
movq %rbx, %rdx
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001CapturedCB
int pit001CapturedCB( char *strIn )
{
    static unsigned long int lastTimeCaptured = 0L;
    // logPrintf( LOG_LEVEL_INFO, "pit001", "Captured Objective Event ::%s::", strIn );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Captured Objective Event" );

    // system generates multiple 'captured' report, so it is necessary
    // to add a 10-second window filter to make sure only one gets fired off.
    //
    if ( lastTimeCaptured + 10L < apiTimeGet() ) {

	apiSay( pit001Config.stringParameterExample3 );
        lastTimeCaptured = apiTimeGet();
	// apiServerRestart();

    }

    return 0;
}

// Assembly:
pushq %rbx
leaq 0x7481(%rip), %rsi      # 0x1fb04
leaq 0x762a(%rip), %rdx      # 0x1fcb4
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
movq 0x21cf7b(%rip), %rbx    # 0x235618
addq $0xa, %rbx
callq 0x114b2
cmpq %rax, %rbx
jae 0x186c5
leaq 0x21cb62(%rip), %rdi    # 0x235214
xorl %eax, %eax
callq 0x12fba
callq 0x114b2
movq %rax, 0x21cf53(%rip)    # 0x235618
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001ClientSynthDelCB
int pit001ClientSynthDelCB( char *strIn )
{
    static char playerName[256], playerGUID[256], playerIP[256];

    rosterParsePlayerSynthDisConn( strIn, 256, playerName, playerGUID, playerIP );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Synthetic DEL Callback Name ::%s:: IP ::%s:: GUID ::%s::", playerName, playerIP, playerGUID );
    apiSay( "pit001: Disconnect %s", playerName );

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x21cf07(%rip), %rbx    # 0x235620
leaq 0x21d000(%rip), %r14    # 0x235720
leaq 0x21d0f9(%rip), %r15    # 0x235820
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x150b3
leaq 0x73c3(%rip), %rsi      # 0x1fb04
leaq 0x75b7(%rip), %rdx      # 0x1fcff
movl $0x2, %edi
movq %rbx, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x1a227
leaq 0x75d4(%rip), %rdi      # 0x1fd38
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001ClientSynthAddCB
int pit001ClientSynthAddCB( char *strIn )
{
    static char playerName[256], playerGUID[256], playerIP[256];

    rosterParsePlayerSynthConn( strIn, 256, playerName, playerGUID, playerIP );
    logPrintf( LOG_LEVEL_INFO, "pit001", "Synthetic ADD Callback Name ::%s:: IP ::%s:: GUID ::%s::", playerName, playerIP, playerGUID );
    apiSay( "pit001: Connected %s", playerName );

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x21d19e(%rip), %rbx    # 0x235920
leaq 0x21d297(%rip), %r14    # 0x235a20
leaq 0x21d390(%rip), %r15    # 0x235b20
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x14fb7
leaq 0x735a(%rip), %rsi      # 0x1fb04
leaq 0x759d(%rip), %rdx      # 0x1fd4e
movl $0x2, %edi
movq %rbx, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x1a227
leaq 0x75ba(%rip), %rdi      # 0x1fd87
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001WinLose
int pit001WinLose( char *strIn )
{
    int isTeam0, humanSide;
    char outStr[256];

    humanSide = rosterGetCoopSide();
    isTeam0   = (NULL != strstr( strIn, "Team 0" ));

    switch ( humanSide ) {
    case 0:
        if ( !isTeam0 ) strlcpy( outStr, "Co-op Humans Win", 256 );
        break;
    case 1:
        if (  isTeam0 ) strlcpy( outStr, "Co-opHumans Lose", 256 );
        break;
    default:
        strlcpy( outStr, "PvP WinLose", 256 );
        break;
    }

    apiSay( "pit001: %s", outStr );
    logPrintf( LOG_LEVEL_INFO, "pit001", outStr );

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
callq 0x1427e
movl %eax, %ebx
leaq 0x7576(%rip), %rsi      # 0x1fdb1
movq %r14, %rdi
callq 0x83b0
cmpl $0x1, %ebx
je 0x1885a
testl %ebx, %ebx
jne 0x18871
testq %rax, %rax
jne 0x18887
movups 0x7560(%rip), %xmm0     # 0x1fdb8
jmp 0x18866
testq %rax, %rax
je 0x18887
movups 0x7563(%rip), %xmm0     # 0x1fdc9
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
jmp 0x18887
movabsq $0x4c6e695720507650, %rax # imm = 0x4C6E695720507650
movq %rax, (%rsp)
movl $0x65736f, 0x8(%rsp)    # imm = 0x65736F
leaq 0x7558(%rip), %rdi      # 0x1fde6
movq %rsp, %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12fba
leaq 0x7262(%rip), %rsi      # 0x1fb04
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001Travel
int pit001Travel( char *strIn )
{
    char *mapName, *scenario, *mutator;
    int humanSide;

    mapName = rosterGetMapName();
    scenario = rosterGetScenario();
    mutator = rosterGetMutator();
    humanSide = rosterGetCoopSide();

    logPrintf( LOG_LEVEL_INFO, "pit001", "Change map to ::%s:: Scenario ::%s:: Mutator ::%s:: Human ::%d::", 
        mapName, scenario, mutator, humanSide );
    apiSay( "pit001: Test Map-Scenario %s::%s::%s::%d::", mapName, scenario, mutator, humanSide );

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x14262
movq %rax, %rbx
callq 0x143f8
movq %rax, %r14
callq 0x14420
movq %rax, %r15
callq 0x1427e
movl %eax, %ebp
movl %eax, (%rsp)
leaq 0x7216(%rip), %rsi      # 0x1fb04
leaq 0x74fc(%rip), %rdx      # 0x1fdf1
movl $0x2, %edi
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1a227
leaq 0x7521(%rip), %rdi      # 0x1fe32
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001SessionLog
int pit001SessionLog( char *strIn )
{
    char *sessionID;

    sessionID = rosterGetSessionID();

    logPrintf( LOG_LEVEL_INFO, "pit001", "Session ID ::%s::", sessionID );
    apiSay( "pit001: Session ID %s", sessionID );

    return 0;
}

// Assembly:
pushq %rbx
callq 0x14209
movq %rax, %rbx
leaq 0x71c3(%rip), %rsi      # 0x1fb04
leaq 0x7515(%rip), %rdx      # 0x1fe5d
movl $0x2, %edi
movq %rax, %rcx
xorl %eax, %eax
callq 0x1a227
leaq 0x7511(%rip), %rdi      # 0x1fe6f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pit001.c
// Function: pit001ObjectSynth
int pit001ObjectSynth( char *strIn )
{
    char *obj, *typ; 

    obj = rosterGetObjective();
    typ = rosterGetObjectiveType();

    logPrintf( LOG_LEVEL_INFO, "pit001", "Roster Objective is ::%s::, Type is ::%s::", obj, typ ); 
    apiSay( "pit001: Roster Objective is ::%s::, Type is ::%s::", obj, typ ); 

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1423e
movq %rax, %rbx
callq 0x14246
movq %rax, %r14
leaq 0x717d(%rip), %rsi      # 0x1fb04
leaq 0x74ff(%rip), %rdx      # 0x1fe8d
movl $0x2, %edi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1a227
leaq 0x74de(%rip), %rdi      # 0x1fe85
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x12fba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pigreetings.c
// Function: pigreetingsClientSynthDelCB
int pigreetingsClientSynthDelCB( char *strIn )
{
    char playerName[256], playerGUID[256], playerIP[256];


    rosterParsePlayerSynthDisConn( strIn, 256, playerName, playerGUID, playerIP );
    // rosterParsePlayerDisConn( strIn, playerName, playerGUID, playerIP );
    // logPrintf( LOG_LEVEL_CRITICAL, "pigreetings", "SynDel Raw ::%s::", strIn );
    logPrintf( LOG_LEVEL_CRITICAL, "pigreetings", "SynDel Client ::%s:: GUID ::%s:: IP ::%s::", playerName, playerGUID, playerIP );
    // 
    if (!_isIncognito( playerGUID ) && !_isMaskDisconnect() ) {
        if ( 0 != strlen( pigreetingsConfig.disconnected ) ) 
            apiSay( "%s%s%s %s [%d]", 
                pigreetingsConfig.disconnectedPrefix,
                playerName, 
                pigreetingsConfig.disconnectedPostfix,
                pigreetingsConfig.disconnected, apiPlayersGetCount() );
        logPrintf( LOG_LEVEL_CRITICAL, "pigreetings", "%s disconnected [%d]", playerName, apiPlayersGetCount() );
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsp, %rbx
leaq 0x200(%rsp), %r14
leaq 0x100(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x150b3
leaq 0x70f0(%rip), %rsi      # 0x20324
leaq 0x70f5(%rip), %rdx      # 0x20330
xorl %edi, %edi
movq %rbx, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1a227
leaq 0x2221e8(%rip), %rdi    # 0x23b43c
movq %r14, %rsi
callq 0x83b0
testq %rax, %rax
jne 0x192db
cmpl $0x0, 0x21c9c0(%rip)    # 0x235c28
je 0x19282
callq 0x114b2
subq 0x2255da(%rip), %rax    # 0x23e850
movslq 0x21c9ab(%rip), %rcx    # 0x235c28
cmpq %rcx, %rax
jb 0x192db
cmpb $0x0, 0x222db3(%rip)    # 0x23c03c
je 0x192b9
callq 0x134dc
leaq 0x70c4(%rip), %rdi      # 0x2035b
leaq 0x22419e(%rip), %rsi    # 0x23d43c
leaq 0x224597(%rip), %rcx    # 0x23d83c
leaq 0x222d90(%rip), %r8     # 0x23c03c
movq %rsp, %rdx
movl %eax, %r9d
xorl %eax, %eax
callq 0x12fba
callq 0x134dc
leaq 0x705f(%rip), %rsi      # 0x20324
leaq 0x709e(%rip), %rdx      # 0x2036a
movq %rsp, %rcx
xorl %edi, %edi
movl %eax, %r8d
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pigreetings.c
// Function: pigreetingsClientSynthAddCB
int pigreetingsClientSynthAddCB( char *strIn )
{
    char playerName[256], playerGUID[256], playerIP[256];

    rosterParsePlayerSynthConn( strIn, 256, playerName, playerGUID, playerIP );
    if (!_isIncognito( playerGUID )) {
        if ( (apiTimeGet() - timeRestarted) > PIGREETINGS_RESTART_LOCKOUT_SEC ) {   // check if we are restarting
       
           if  ( apiIsAdmin( playerGUID ) && (0 != strlen( pigreetingsConfig.connectedAsAdmin)) ) 
               apiSay( "%s%s%s %s [%d]", 
                    pigreetingsConfig.connectedAsAdminPrefix,
                    playerName, 
                    pigreetingsConfig.connectedAsAdminPostfix,
                    pigreetingsConfig.connectedAsAdmin, apiPlayersGetCount() );
           else if ( 0 != strlen( pigreetingsConfig.connected ))
               apiSay( "%s%s%s %s [%d]", 
                    pigreetingsConfig.connectedPrefix,
                    playerName, 
                    pigreetingsConfig.connectedPostfix,
                    pigreetingsConfig.connected, apiPlayersGetCount() );
        }
        logPrintf( LOG_LEVEL_CRITICAL, "pigreetings", "SynAdd Client ::%s::%s::%s::", playerName, playerGUID, playerIP );
    }
    else {
        logPrintf( LOG_LEVEL_CRITICAL, "pigreetings", "SynAdd Client [incognito] ::%s::%s::%s::", playerName, playerGUID, playerIP );
    }
    return 0;
}

// Assembly:
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsp, %rdx
leaq 0x100(%rsp), %rbx
leaq 0x200(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
callq 0x14fb7
leaq 0x222123(%rip), %rdi    # 0x23b43c
movq %rbx, %rsi
callq 0x83b0
testq %rax, %rax
je 0x19332
leaq 0x706f(%rip), %rbx      # 0x2039c
jmp 0x193bf
callq 0x114b2
subq 0x225502(%rip), %rax    # 0x23e840
leaq 0x703a(%rip), %rbx      # 0x2037f
cmpq $0x1f, %rax
jb 0x193bf
leaq 0x100(%rsp), %rdi
callq 0x13a6a
testl %eax, %eax
je 0x19388
cmpb $0x0, 0x2228d9(%rip)    # 0x23bc3c
je 0x19388
callq 0x134dc
leaq 0x6fea(%rip), %rdi      # 0x2035b
leaq 0x2238c4(%rip), %rsi    # 0x23cc3c
leaq 0x223cbd(%rip), %rcx    # 0x23d03c
leaq 0x2228b6(%rip), %r8     # 0x23bc3c
jmp 0x193b2
cmpb $0x0, 0x2224ad(%rip)    # 0x23b83c
je 0x193bf
callq 0x134dc
leaq 0x6fbe(%rip), %rdi      # 0x2035b
leaq 0x223098(%rip), %rsi    # 0x23c43c
leaq 0x223491(%rip), %rcx    # 0x23c83c
leaq 0x22248a(%rip), %r8     # 0x23b83c
movq %rsp, %rdx
movl %eax, %r9d
xorl %eax, %eax
callq 0x12fba
leaq 0x6f5e(%rip), %rsi      # 0x20324
movq %rsp, %rcx
leaq 0x100(%rsp), %r8
leaq 0x200(%rsp), %r9
xorl %edi, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pigreetings.c
// Function: pigreetingsRoundStartCB
int pigreetingsRoundStartCB( char *strIn )
{
    if ( 0 != strlen(pigreetingsConfig.serverGreetings[0] )) 
        apiSay( "%s", pigreetingsConfig.serverGreetings[0] );
    if ( 0 != strlen(pigreetingsConfig.serverGreetings[1] )) 
        apiSay( "%s", pigreetingsConfig.serverGreetings[1] );

    // start the 'ads' periodic printing service
    //
    if ( 0 != pigreetingsConfig.adsDelay )
        alarmReset( alarmAds, pigreetingsConfig.adsDelay );

    return 0;
}

// Assembly:
pushq %rax
cmpb $0x0, 0x21c835(%rip)    # 0x235c3c
je 0x1941e
leaq 0x5874(%rip), %rdi      # 0x1ec84
leaq 0x21c825(%rip), %rsi    # 0x235c3c
xorl %eax, %eax
callq 0x12fba
cmpb $0x0, 0x21cc17(%rip)    # 0x23603c
je 0x1943c
leaq 0x5856(%rip), %rdi      # 0x1ec84
leaq 0x21cc07(%rip), %rsi    # 0x23603c
xorl %eax, %eax
callq 0x12fba
movslq 0x21c7f1(%rip), %rsi    # 0x235c34
testq %rsi, %rsi
je 0x19454
movq 0x2253f9(%rip), %rdi    # 0x23e848
callq 0xf953
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pigreetings.c
// Function: pigreetingsRoundEndCB
int pigreetingsRoundEndCB( char *strIn )
{
    // cancel the 'ads' alarm
    //
    alarmCancel( alarmAds );
    lastRoundEndTime = apiTimeGet();
    logPrintf( LOG_LEVEL_INFO, "pigreetings", "Round End Event" );
    // apiSay("pigreeting Test: End of Round");
    return 0;
}

// Assembly:
pushq %rax
movq 0x2253e8(%rip), %rdi    # 0x23e848
callq 0xf974
callq 0x114b2
movq %rax, 0x2253df(%rip)    # 0x23e850
leaq 0x6eac(%rip), %rsi      # 0x20324
leaq 0x6f46(%rip), %rdx      # 0x203c5
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pigreetings.c
// Function: pigreetingsCapturedCB
int pigreetingsCapturedCB( char *strIn )
{
    static unsigned long int lastTimeCaptured = 0L;
    static int lastIndex = 0;

    // only display rules when enabled (commonly disabled for private servers
    //
    if ( pigreetingsConfig.showRules ) {

        // system generates multiple 'captured' report, so it is necessary
        // to add a 10-second window filter to make sure only one gets fired off.
        //
        if ( lastTimeCaptured + 10L < apiTimeGet() ) {
            if ( 0 != strlen(pigreetingsConfig.serverRules[lastIndex] )) 
                apiSay( "%s", pigreetingsConfig.serverRules[lastIndex] );
	    lastIndex = ( lastIndex + 1 ) % 10;
            lastTimeCaptured = apiTimeGet();
        }
    }

    // start the 'ads' periodic printing service
    //
    if ( 0 != pigreetingsConfig.adsDelay )
        alarmReset( alarmAds, pigreetingsConfig.adsDelay );

    return 0;
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x21c795(%rip)    # 0x235c2c
je 0x19516
movq 0x2253b8(%rip), %rbx    # 0x23e858
addq $0xa, %rbx
callq 0x114b2
cmpq %rax, %rbx
jae 0x19516
movl 0x2253ac(%rip), %eax    # 0x23e860
shlq $0xa, %rax
leaq 0x21c761(%rip), %rcx    # 0x235c20
cmpb $0x0, 0x81c(%rax,%rcx)
je 0x194e2
leaq (%rax,%rcx), %rsi
addq $0x81c, %rsi            # imm = 0x81C
leaq 0x57a9(%rip), %rdi      # 0x1ec84
xorl %eax, %eax
callq 0x12fba
movl 0x225378(%rip), %eax    # 0x23e860
movl %eax, %ecx
incl %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x225356(%rip)    # 0x23e860
callq 0x114b2
movq %rax, 0x225342(%rip)    # 0x23e858
movslq 0x21c717(%rip), %rsi    # 0x235c34
testq %rsi, %rsi
je 0x1952e
movq 0x22531f(%rip), %rdi    # 0x23e848
callq 0xf953
xorl %eax, %eax
popq %rbx
retq