LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
leaq 0x7158(%rip), %rdi      # 0x23f74
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, -0x38(%rbp)
callq 0x187d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x819e(%rip), %rsi      # 0x24fdb
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1ce6e
movq -0x30(%rbp), %rdi
leaq 0x71aa(%rip), %rsi      # 0x23fff
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1ce6e
movl $0x0, -0x4(%rbp)
jmp 0x1cf18
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jne 0x1cee9
movq -0x18(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1ce9f
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17cf0
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1cec5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17ee0
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x3, %edi
leaq 0x9c19(%rip), %rsi      # 0x26af2
leaq 0xa954(%rip), %rdx      # 0x27834
movb $0x0, %al
callq 0x21bf0
jmp 0x1cf12
movl $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x2, %edi
leaq 0x9bee(%rip), %rsi      # 0x26af2
leaq 0xa942(%rip), %rdx      # 0x2784d
movb $0x0, %al
callq 0x21bf0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: capRusherEnterZone
static void _capRusherEnterZone( char *playerCharID, char *playerName )
{
    int i;
    int foundIndex = -1; 
    int foundEmpty = -1;

    for (i = 0; i<SISSM_MAXPLAYERS; i++) {
        if ( 0 == strcmp( playerCharID, territorialRushers[i].playerCharID )) {
             foundIndex = i;
             break;
        }
        else if (( foundEmpty == -1 ) && ( 0 == territorialRushers[i].playerCharID[0] )) {
            foundEmpty = i;
        }
    }

    if ( foundIndex == -1 ) 
        foundIndex = foundEmpty;

    if ( foundIndex != -1 ) {
        i = foundIndex;
        strlcpy( territorialRushers[i].playerCharID, playerCharID, 64 );        
        strlcpy( territorialRushers[i].playerName, playerName, 64 );
        territorialRushers[i].playerIsInZone = 1;

        // territorialRushers[i].playerEarlyBreachCumulativeTime - don't update!
        // territorialRushers[i].playerIsInZone  - don't update!

        logPrintf( LOG_LEVEL_DEBUG, "piantirush", "'%s' [%s] early breach detected.", playerName, playerCharID ); 
    }
    else {
        logPrintf(LOG_LEVEL_CRITICAL, "piantirush", "**Internal error - territorialRusher table full" );
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x1d5c2
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x20a926(%rip), %rsi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d589
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1d5c2
cmpl $-0x1, -0x1c(%rbp)
jne 0x1d5b3
movslq -0x14(%rbp), %rcx
leaq 0x20a8f6(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d5b3
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d5b5
jmp 0x1d5b7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d555
cmpl $-0x1, -0x18(%rbp)
jne 0x1d5ce
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x1d66b
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
leaq 0x20a8a7(%rip), %rdi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x40, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rax
leaq 0x20a884(%rip), %rdi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rcx
leaq 0x20a85d(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
movl $0x3, %edi
leaq 0x9497(%rip), %rsi      # 0x26af2
leaq 0xa216(%rip), %rdx      # 0x27878
movb $0x0, %al
callq 0x21bf0
jmp 0x1d682
xorl %edi, %edi
leaq 0x947e(%rip), %rsi      # 0x26af2
leaq 0xa21e(%rip), %rdx      # 0x27899
movb $0x0, %al
callq 0x21bf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq 0x20a7aa(%rip), %rdi    # 0x227e50
callq 0x12aa0
cmpq $0x5, %rax
jle 0x1d7f1
movq -0x8(%rbp), %rdi
leaq 0x8922(%rip), %rsi      # 0x25fe2
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1d7ef
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x11bc0
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
leaq 0x9588(%rip), %rdx      # 0x26c84
callq 0x122d0
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1d7ed
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x11bc0
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
callq 0x193c0
movq -0x128(%rbp), %rdi
movq %rax, %rsi
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1d7eb
leaq -0x60(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x15b30
movq -0x130(%rbp), %rdi
movq %rax, %rsi
movl $0x40, %edx
callq 0x11bc0
leaq -0x60(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1d7e9
leaq -0x120(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x11bc0
cmpl $0x0, 0x14735(%rip)     # 0x31ee4
je 0x1d7dd
cmpl $0x0, 0x20a688(%rip)    # 0x227e40
je 0x1d7dd
leaq -0x120(%rbp), %rsi
leaq 0x94bf(%rip), %rdi      # 0x26c87
leaq 0x2020d1(%rip), %rdx    # 0x21f8a0
addq $0x5838, %rdx           # imm = 0x5838
movb $0x0, %al
callq 0x1d300
leaq -0xa0(%rbp), %rdi
callq 0x1d800
jmp 0x1d7eb
jmp 0x1d7ed
jmp 0x1d7ef
jmp 0x1d7f1
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: capRusherExitZone
static void _capRusherExitZone( char *playerCharID )
{
    int i;
    int foundIndex = -1;

    for (i = 0; i<SISSM_MAXPLAYERS; i++) {
        if ( 0 == strcmp( playerCharID, territorialRushers[i].playerCharID )) {
             foundIndex = i;
             break;
        }
    }
    if ( foundIndex != -1 ) {
        i = foundIndex;
        territorialRushers[i].playerIsInZone = 0;
        logPrintf( LOG_LEVEL_DEBUG, "piantirush", "[%s] early breach area exited.", playerCharID );  
    }
    else {
        logPrintf(LOG_LEVEL_CRITICAL, "piantirush", "**Internal Error -trying to remove nonexistent player from territorialRusher" );
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x1d85b
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
leaq 0x20a661(%rip), %rsi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d84e
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1d85b
jmp 0x1d850
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d81a
cmpl $-0x1, -0x10(%rbp)
je 0x1d8a6
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x20a61e(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rcx
movl $0x3, %edi
leaq 0x925c(%rip), %rsi      # 0x26af2
leaq 0xa02c(%rip), %rdx      # 0x278c9
movb $0x0, %al
callq 0x21bf0
jmp 0x1d8bd
xorl %edi, %edi
leaq 0x9243(%rip), %rsi      # 0x26af2
leaq 0xa032(%rip), %rdx      # 0x278e8
movb $0x0, %al
callq 0x21bf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1bf80
xorl %edi, %edi
callq 0x1b9c0
callq 0x1bf80
movl $0x3, %edi
leaq 0x8579(%rip), %rsi      # 0x26af2
leaq 0x93b5(%rip), %rdx      # 0x27935
movb $0x0, %al
callq 0x21bf0
movl $0x0, 0x2098af(%rip)    # 0x227e40
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x122b0
callq 0x193d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x590b(%rip), %rsi      # 0x23eda
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e5fd
leaq -0x110(%rbp), %rdi
leaq 0x2012b4(%rip), %rsi    # 0x21f8a0
addq $0x2814, %rsi           # imm = 0x2814
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x10(%rbp), %rdi
leaq 0x58de(%rip), %rsi      # 0x23ee6
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e636
leaq -0x110(%rbp), %rdi
leaq 0x20127b(%rip), %rsi    # 0x21f8a0
addq $0x2414, %rsi           # imm = 0x2414
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x110(%rbp), %rdi
movb $0x0, %al
callq 0x1cac0
leaq -0x110(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e664
movl $0x1, 0x2097dc(%rip)    # 0x227e40
cmpl $0x0, 0x209801(%rip)    # 0x227e6c
je 0x1e677
movl $0x0, 0x2097c9(%rip)    # 0x227e40
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x203e15(%rip)    # 0x2224b8
je 0x1e6da
callq 0x193d0
movq %rax, %rdi
leaq 0x8497(%rip), %rsi      # 0x26b4b
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e6d8
leaq 0x2011d6(%rip), %rdi    # 0x21f8a0
addq $0x3420, %rdi           # imm = 0x3420
movb $0x0, %al
callq 0x1cac0
jmp 0x1e6da
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1e9e0
cmpl $0x0, %eax
jne 0x1e737
leaq 0x5205(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e737
leaq 0x201179(%rip), %rdi    # 0x21f8a0
addq $0x6464, %rdi           # imm = 0x6464
movb $0x0, %al
callq 0x1cac0
jmp 0x1e7a2
movq 0x2091e2(%rip), %rdi    # 0x227920
callq 0x12aa0
movl 0x203d73(%rip), %ecx    # 0x2224bc
addl 0x2071a9(%rip), %ecx    # 0x2258f8
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1e78b
leaq 0x201142(%rip), %rdi    # 0x21f8a0
addq $0x2c20, %rdi           # imm = 0x2C20
movb $0x0, %al
callq 0x1cac0
movl $0x0, 0x2096ca(%rip)    # 0x227e40
movq 0x2091a3(%rip), %rdi    # 0x227920
callq 0x12a80
xorl %edi, %edi
callq 0x1b9c0
jmp 0x1e7a0
leaq 0x20110e(%rip), %rdi    # 0x21f8a0
addq $0x3020, %rdi           # imm = 0x3020
movb $0x0, %al
callq 0x1cac0
jmp 0x1e7a2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1e9e0
cmpl $0x0, %eax
jne 0x1e807
leaq 0x5135(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e807
leaq 0x2010a9(%rip), %rdi    # 0x21f8a0
addq $0x6464, %rdi           # imm = 0x6464
movb $0x0, %al
callq 0x1cac0
jmp 0x1e86d
movq 0x209112(%rip), %rdi    # 0x227920
callq 0x12aa0
movslq 0x2058b2(%rip), %rcx    # 0x2240cc
movslq 0x2070cf(%rip), %rdx    # 0x2258f0
addq %rdx, %rcx
cmpq %rcx, %rax
jge 0x1e856
leaq 0x201070(%rip), %rdi    # 0x21f8a0
addq $0x402c, %rdi           # imm = 0x402C
movb $0x0, %al
callq 0x1cac0
movq 0x2090db(%rip), %rdi    # 0x227920
movl $0x2, %esi
callq 0x12a40
callq 0x1bf90
jmp 0x1e86b
leaq 0x201043(%rip), %rdi    # 0x21f8a0
addq $0x442c, %rdi           # imm = 0x442C
movb $0x0, %al
callq 0x1cac0
jmp 0x1e86d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: trainingModeReminderCB
static int _trainingModeReminderCB( char *str )
{
    if ( 0 != (int) strlen( piantirushConfig.trainingModeMsg ) )  {
        if ( NULL != strstr( rosterGetObjectiveType(), "WeaponCache" ) ) {
            _localSay( piantirushConfig.destroyOkPrompt );
            _localSay( piantirushConfig.trainingModeMsg );
        }
        else {
            _localSay( piantirushConfig.breachOkPrompt );
            _localSay( piantirushConfig.trainingModeMsg );
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x207071(%rip), %rdi    # 0x225904
callq 0x8110
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1e916
callq 0x193d0
movq %rax, %rdi
leaq 0x829c(%rip), %rsi      # 0x26b4b
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1e8ea
leaq 0x200fdb(%rip), %rdi    # 0x21f8a0
addq $0x2c20, %rdi           # imm = 0x2C20
movb $0x0, %al
callq 0x1cac0
leaq 0x200fc6(%rip), %rdi    # 0x21f8a0
addq $0x6064, %rdi           # imm = 0x6064
movb $0x0, %al
callq 0x1cac0
jmp 0x1e914
leaq 0x200faf(%rip), %rdi    # 0x21f8a0
addq $0x402c, %rdi           # imm = 0x402C
movb $0x0, %al
callq 0x1cac0
leaq 0x200f9a(%rip), %rdi    # 0x21f8a0
addq $0x6064, %rdi           # imm = 0x6064
movb $0x0, %al
callq 0x1cac0
jmp 0x1e916
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: fastChecksum
static unsigned long _fastChecksum( char *strIn ) 
{
    int i;
    register unsigned int checksum = 0L;
    register unsigned char *p;
    int len = (int) strlen( strIn );

    p = (unsigned char *) strIn;
    if ( len > 255 ) len = 255;
    for ( i = 0; i<len; i++ ) checksum += (unsigned int) *p++;
    return ((unsigned long) checksum); 
}

// 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, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0xff, -0x1c(%rbp)
jle 0x1e997
movl $0xff, -0x1c(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1e9c9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e99e
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x0, 0x207712(%rip)    # 0x226108
jne 0x1ea01
movl $0x1, -0x4(%rbp)
jmp 0x1ea45
movq 0x209428(%rip), %rax    # 0x227e30
movslq 0x2076f9(%rip), %rcx    # 0x226108
addq %rcx, %rax
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
ja 0x1ea30
movl $0x1, -0x4(%rbp)
jmp 0x1ea43
cmpq $0x0, 0x2093f8(%rip)    # 0x227e30
jne 0x1ea41
movl $0x1, -0x4(%rbp)
jmp 0x1ea43
jmp 0x1ea45
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pSetF
void p2pSetF( char *varName, double value )
{
    int i;

    if ( -1 != (i = _p2pSearch( varName, 1 ))) {
        strlcpy( p2pVarNames[i], varName, P2P_MAXSTR );
        snprintf( p2pVarValues[i], P2P_MAXSTR, "%lf", value );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1eac7
movslq -0x14(%rbp), %rax
leaq 0x20df08(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rax
leaq 0x215ee8(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
movsd -0x10(%rbp), %xmm0
movl $0x80, %esi
leaq 0x6600(%rip), %rdx      # 0x250c0
movb $0x1, %al
callq 0x8180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x1eb2e
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x20de8b(%rip), %rsi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1eb21
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1eb2e
jmp 0x1eb23
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eaed
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x10(%rbp), %eax
jne 0x1ebe6
cmpl $0x0, -0xc(%rbp)
je 0x1ebe6
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x1ebc3
movslq -0x14(%rbp), %rax
leaq 0x20de2f(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1ebb6
movslq -0x14(%rbp), %rax
leaq 0x20de0e(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rax
leaq 0x215dee(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x122b0
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1ebc3
jmp 0x1ebb8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eb4d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x10(%rbp), %eax
jne 0x1ebe4
xorl %edi, %edi
leaq 0x8e32(%rip), %rsi      # 0x27a08
leaq 0x8e2f(%rip), %rdx      # 0x27a0c
movb $0x0, %al
callq 0x21bf0
jmp 0x1ebe6
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pSetL
void p2pSetL( char *varName, unsigned long value )
{
    int i;

    if ( -1 != (i = _p2pSearch( varName, 1 ))) {
        strlcpy( p2pVarNames[i], varName, P2P_MAXSTR );
        snprintf( p2pVarValues[i], P2P_MAXSTR, "%lu", value );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1ec65
movslq -0x14(%rbp), %rax
leaq 0x20dd69(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rax
leaq 0x215d49(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rcx
movl $0x80, %esi
leaq 0x8d4a(%rip), %rdx      # 0x279a8
movb $0x0, %al
callq 0x8180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pSetS
void p2pSetS( char *varName, char *value )
{
    int i;

    if ( -1 != (i = _p2pSearch( varName, 1 ))) {
        strlcpy( p2pVarNames[i], varName, P2P_MAXSTR );
        strlcpy( p2pVarValues[i], value, P2P_MAXSTR );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1ecdc
movslq -0x14(%rbp), %rax
leaq 0x20dce9(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0x11bc0
movslq -0x14(%rbp), %rax
leaq 0x215cc9(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x80, %edx
callq 0x11bc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1ed8a
movslq -0x14(%rbp), %rax
leaq 0x215c61(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1ed4f
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movslq -0x14(%rbp), %rax
leaq 0x215c36(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
leaq 0x6358(%rip), %rsi      # 0x250c0
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x1ed88
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x1ed8a
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1ee37
movslq -0x14(%rbp), %rax
leaq 0x215bb4(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1edfc
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ee35
movslq -0x14(%rbp), %rax
leaq 0x215b89(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
leaq 0x8b93(%rip), %rsi      # 0x279a8
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x1ee33
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ee35
jmp 0x1ee37
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1ead0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1ee9e
movslq -0x14(%rbp), %rax
leaq 0x215b0c(%rip), %rsi    # 0x234990
shlq $0x7, %rax
addq %rax, %rsi
leaq 0x21dafe(%rip), %rdi    # 0x23c990
movl $0x80, %edx
callq 0x11bc0
jmp 0x1eeb3
movq -0x10(%rbp), %rsi
leaq 0x21dae7(%rip), %rdi    # 0x23c990
movl $0x80, %edx
callq 0x11bc0
leaq 0x21dad6(%rip), %rax    # 0x23c990
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pInit
void p2pInit( void )
{
    int i;

    for (i=0; i<P2P_MAXELEM; i++) {
        strclr( p2pVarNames[i] );
        strclr( p2pVarValues[i] );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x1ef11
movslq -0x4(%rbp), %rax
leaq 0x20daad(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x215a96(%rip), %rdi    # 0x234990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x122b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1eecf
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pDebugDump
void p2pDebugDump( void )
{
    int i;

    for (i=0; i<P2P_MAXELEM; i++) {
        if (0 != strlen( p2pVarNames[i] ) ) 
            printf("%06d::%s::%s\n", i, p2pVarNames[i], p2pVarValues[i] );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x1ef9b
movslq -0x4(%rbp), %rax
leaq 0x20da4d(%rip), %rdi    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1ef8e
movl -0x4(%rbp), %esi
movslq -0x4(%rbp), %rax
leaq 0x20da29(%rip), %rdx    # 0x22c990
shlq $0x7, %rax
addq %rax, %rdx
movslq -0x4(%rbp), %rax
leaq 0x215a17(%rip), %rcx    # 0x234990
shlq $0x7, %rax
addq %rax, %rcx
leaq 0x8a25(%rip), %rdi      # 0x279ac
movb $0x0, %al
callq 0x8170
jmp 0x1ef90
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1ef2f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0x1eec0
leaq 0x89fa(%rip), %rdi      # 0x279ba
leaq 0x89fb(%rip), %rsi      # 0x279c2
callq 0x1ec70
leaq 0x89e7(%rip), %rdi      # 0x279ba
leaq 0x89f0(%rip), %rsi      # 0x279ca
callq 0x1ec70
leaq 0x89d4(%rip), %rdi      # 0x279ba
leaq 0x89e5(%rip), %rsi      # 0x279d2
callq 0x1ec70
leaq 0x89c1(%rip), %rdi      # 0x279ba
leaq 0x89da(%rip), %rsi      # 0x279da
callq 0x1ec70
leaq 0x89ae(%rip), %rdi      # 0x279ba
leaq 0x973c(%rip), %rsi      # 0x2874f
callq 0x1ee50
movq %rax, %rsi
leaq 0x89c2(%rip), %rdi      # 0x279e4
movb $0x0, %al
callq 0x8170
leaq 0x89bd(%rip), %rdi      # 0x279ed
movsd 0x8968(%rip), %xmm0     # 0x279a0
callq 0x1ea50
leaq 0x89a9(%rip), %rdi      # 0x279ed
movsd 0x894c(%rip), %xmm0     # 0x27998
callq 0x1ea50
leaq 0x8995(%rip), %rdi      # 0x279ed
movsd 0x8930(%rip), %xmm0     # 0x27990
callq 0x1ea50
leaq 0x8981(%rip), %rdi      # 0x279ed
movsd 0x8914(%rip), %xmm0     # 0x27988
callq 0x1ea50
leaq 0x8980(%rip), %rdi      # 0x27a00
movsd 0x88f8(%rip), %xmm0     # 0x27980
callq 0x1ecf0
leaq 0x8962(%rip), %rdi      # 0x279f6
movb $0x1, %al
callq 0x8170
callq 0x1ef20
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8a90
movq %rax, %rdi
callq 0x9370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8954(%rip), %rsi      # 0x27a28
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x21d92a(%rip)    # 0x23ca10
movq -0x8(%rbp), %rdi
leaq 0x894a(%rip), %rsi      # 0x27a3b
leaq 0x8961(%rip), %rdx      # 0x27a59
callq 0x9430
movq %rax, %rsi
leaq 0x21d909(%rip), %rdi    # 0x23ca10
addq $0x4, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x8948(%rip), %rsi      # 0x27a68
leaq 0x8960(%rip), %rdx      # 0x27a87
callq 0x9430
movq %rax, %rsi
leaq 0x21d8da(%rip), %rdi    # 0x23ca10
addq $0x404, %rdi            # imm = 0x404
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x8945(%rip), %rsi      # 0x27a97
leaq 0x895d(%rip), %rdx      # 0x27ab6
callq 0x9430
movq %rax, %rsi
leaq 0x21d8a8(%rip), %rdi    # 0x23ca10
addq $0x804, %rdi            # imm = 0x804
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x8949(%rip), %rsi      # 0x27acd
movsd 0x8894(%rip), %xmm0     # 0x27a20
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x21e479(%rip)    # 0x23d614
movq -0x8(%rbp), %rdi
callq 0x93f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/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 %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
leaq -0x210(%rbp), %rcx
leaq -0x310(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0x1ace0
leaq -0x110(%rbp), %rcx
leaq -0x210(%rbp), %r8
leaq -0x310(%rbp), %r9
movl $0x2, %edi
leaq 0x88e9(%rip), %rsi      # 0x27aec
leaq 0x9160(%rip), %rdx      # 0x2836a
movb $0x0, %al
callq 0x21bf0
callq 0x17fe0
cmpl $0x8, %eax
jl 0x1f277
leaq -0x210(%rbp), %rdi
leaq 0x88ca(%rip), %rsi      # 0x27af3
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1f260
leaq -0x210(%rbp), %rsi
xorl %edi, %edi
leaq 0x88bf(%rip), %rdx      # 0x27b05
callq 0x17cf0
leaq -0x110(%rbp), %rsi
leaq 0x88df(%rip), %rdi      # 0x27b38
movb $0x0, %al
callq 0x178d0
leaq -0x110(%rbp), %rsi
leaq 0x88ef(%rip), %rdi      # 0x27b5d
movb $0x0, %al
callq 0x178d0
jmp 0x1f28c
leaq -0x110(%rbp), %rsi
leaq 0x88f8(%rip), %rdi      # 0x27b7d
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
leaq -0x210(%rbp), %rcx
leaq -0x310(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0x1ada0
leaq -0x110(%rbp), %rcx
leaq -0x210(%rbp), %r8
leaq -0x310(%rbp), %r9
movl $0x2, %edi
leaq 0x87f9(%rip), %rsi      # 0x27aec
leaq 0x8896(%rip), %rdx      # 0x27b90
movb $0x0, %al
callq 0x21bf0
leaq -0x110(%rbp), %rsi
leaq 0x889b(%rip), %rdi      # 0x27baa
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x871d(%rip), %rsi      # 0x27aec
leaq 0x880f(%rip), %rdx      # 0x27be5
movb $0x0, %al
callq 0x21bf0
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x1b180
leaq -0x110(%rbp), %rcx
movl $0x2, %edi
leaq 0x86e7(%rip), %rsi      # 0x27aec
leaq 0x87f1(%rip), %rdx      # 0x27bfd
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x86ad(%rip), %rsi      # 0x27aec
leaq 0x87c7(%rip), %rdx      # 0x27c0d
movb $0x0, %al
callq 0x21bf0
leaq 0x45ef(%rip), %rdi      # 0x23a43
leaq 0x82dc(%rip), %rsi      # 0x27737
callq 0x176f0
leaq 0x45eb(%rip), %rdi      # 0x23a52
leaq 0x82c9(%rip), %rsi      # 0x27737
callq 0x176f0
leaq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq 0x45bb(%rip), %rdi      # 0x23a43
callq 0x17720
movq -0x118(%rbp), %rdi
movq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x110(%rbp), %rdx
leaq 0x8776(%rip), %rdi      # 0x27c25
leaq 0x21d55a(%rip), %rsi    # 0x23ca10
addq $0x4, %rsi
movb $0x0, %al
callq 0x178d0
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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
leaq 0x8534(%rip), %rsi      # 0x27aec
leaq 0x86dd(%rip), %rdx      # 0x27c9c
movb $0x0, %al
callq 0x21bf0
movq 0x21e04b(%rip), %rax    # 0x23d618
addq $0xa, %rax
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f607
leaq 0x21d423(%rip), %rdi    # 0x23ca10
addq $0x804, %rdi            # imm = 0x804
movb $0x0, %al
callq 0x178d0
callq 0x150c0
movq %rax, 0x21e011(%rip)    # 0x23d618
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x21df74(%rip), %rdx    # 0x23d620
leaq 0x21e06d(%rip), %rcx    # 0x23d720
leaq 0x21e166(%rip), %r8     # 0x23d820
callq 0x1abd0
movl $0x2, %edi
leaq 0x8421(%rip), %rsi      # 0x27aec
leaq 0x8615(%rip), %rdx      # 0x27ce7
leaq 0x21df47(%rip), %rcx    # 0x23d620
leaq 0x21e140(%rip), %r8     # 0x23d820
leaq 0x21e039(%rip), %r9     # 0x23d720
movb $0x0, %al
callq 0x21bf0
leaq 0x862b(%rip), %rdi      # 0x27d20
leaq 0x21df24(%rip), %rsi    # 0x23d620
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x21e1f4(%rip), %rdx    # 0x23d920
leaq 0x21e2ed(%rip), %rcx    # 0x23da20
leaq 0x21e3e6(%rip), %r8     # 0x23db20
callq 0x1aa80
movl $0x2, %edi
leaq 0x83a1(%rip), %rsi      # 0x27aec
leaq 0x85e4(%rip), %rdx      # 0x27d36
leaq 0x21e1c7(%rip), %rcx    # 0x23d920
leaq 0x21e3c0(%rip), %r8     # 0x23db20
leaq 0x21e2b9(%rip), %r9     # 0x23da20
movb $0x0, %al
callq 0x21bf0
leaq 0x85fa(%rip), %rdi      # 0x27d6f
leaq 0x21e1a4(%rip), %rsi    # 0x23d920
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
callq 0x19450
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8577(%rip), %rsi      # 0x27d99
callq 0x8390
testq %rax, %rax
setne %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x114(%rbp)
testl %eax, %eax
je 0x1f84f
jmp 0x1f842
movl -0x114(%rbp), %eax
subl $0x1, %eax
je 0x1f86f
jmp 0x1f88f
cmpl $0x0, -0xc(%rbp)
jne 0x1f86d
leaq -0x110(%rbp), %rdi
leaq 0x853d(%rip), %rsi      # 0x27da0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1f8a7
cmpl $0x0, -0xc(%rbp)
je 0x1f88d
leaq -0x110(%rbp), %rdi
leaq 0x852e(%rip), %rsi      # 0x27db1
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1f8a7
leaq -0x110(%rbp), %rdi
leaq 0x8525(%rip), %rsi      # 0x27dc2
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x110(%rbp), %rsi
leaq 0x8519(%rip), %rdi      # 0x27dce
movb $0x0, %al
callq 0x178d0
leaq -0x110(%rbp), %rdx
movl $0x2, %edi
leaq 0x821d(%rip), %rsi      # 0x27aec
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)