LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupIPFromGUID
char *rosterLookupIPFromGUID( char *playerGUID )
{
    static char playerIP[256];
    int i;
    strclr( playerIP );
    for (i=0; i<ROSTER_MAX; i++) {
        if ( 0 == strcmp( masterRoster[i].steamID, playerGUID )) {
            strlcpy( playerIP, masterRoster[i].IPaddress, 256 );
            break;
        }
    }
    return( playerIP );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2002f2(%rip), %rdi    # 0x2150a0
callq 0xf829
leaq 0x1f3986(%rip), %r14    # 0x208740
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0x14de5
addq $-0x190, %r15           # imm = 0xFE70
addq $0x190, %r14            # imm = 0x190
cmpq $-0xc800, %r15          # imm = 0xFFFF3800
jne 0x14dbd
jmp 0x14e07
leaq 0x1f38b4(%rip), %rsi    # 0x2086a0
subq %r15, %rsi
addq $0xf0, %rsi
leaq 0x2002a3(%rip), %rdi    # 0x2150a0
movl $0x100, %edx            # imm = 0x100
callq 0xf384
leaq 0x200292(%rip), %rax    # 0x2150a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupSteamIDFromName
char *rosterLookupSteamIDFromName( char *playerName )
{
    static char steamID[256];
    int i;

    strclr( steamID );
    for (i=0; i<ROSTER_MAX; i++) {
        if ( 0 == strcmp( masterRoster[i].playerName, playerName )) {
            strlcpy( steamID, masterRoster[i].steamID, 256 ); 
            break;
        }
    }
    return( steamID );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x20037d(%rip), %rdi    # 0x2151a0
callq 0xf829
leaq 0x1f38c1(%rip), %r14    # 0x2086f0
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0x14e5a
addq $-0x190, %r15           # imm = 0xFE70
addq $0x190, %r14            # imm = 0x190
cmpq $-0xc800, %r15          # imm = 0xFFFF3800
jne 0x14e32
jmp 0x14e7c
leaq 0x1f383f(%rip), %rsi    # 0x2086a0
subq %r15, %rsi
addq $0xa0, %rsi
leaq 0x20032e(%rip), %rdi    # 0x2151a0
movl $0x100, %edx            # imm = 0x100
callq 0xf384
leaq 0x20031d(%rip), %rax    # 0x2151a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupSteamIDFromPartialName
char *rosterLookupSteamIDFromPartialName( char *partialName, int minChars  )
{
    static char steamID[256];
    int i, matchCount = 0;

    if ( (int) strlen( partialName ) >= minChars ) {
        strclr( steamID );
        for (i=0; i<ROSTER_MAX; i++) {
            if ( NULL != strcasestr( masterRoster[i].playerName, partialName )) {
                strlcpy( steamID, masterRoster[i].steamID, 256 ); 
                matchCount++;
                break;
            }
        }
    }
    if ( matchCount != 1 ) strclr( steamID );

    return( steamID );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x8120
cmpl %ebp, %eax
jl 0x14edb
leaq 0x2003fb(%rip), %rdi    # 0x2152a0
callq 0xf829
leaq 0x1f383f(%rip), %r14    # 0x2086f0
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8350
testq %rax, %rax
jne 0x14ee9
addq $-0x190, %r15           # imm = 0xFE70
addq $0x190, %r14            # imm = 0x190
cmpq $-0xc800, %r15          # imm = 0xFFFF3800
jne 0x14eb4
leaq 0x2003be(%rip), %rdi    # 0x2152a0
callq 0xf829
jmp 0x14f0b
leaq 0x1f37b0(%rip), %rsi    # 0x2086a0
subq %r15, %rsi
addq $0xa0, %rsi
leaq 0x20039f(%rip), %rdi    # 0x2152a0
movl $0x100, %edx            # imm = 0x100
callq 0xf384
leaq 0x20038e(%rip), %rax    # 0x2152a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupIPFromName
char *rosterLookupIPFromName( char *playerName )
{
    static char playerIP[256];
    int i;
    strclr( playerIP );
    for (i=0; i<ROSTER_MAX; i++) {
        if ( 0 == strcmp( masterRoster[i].playerName, playerName )) {
            strlcpy( playerIP, masterRoster[i].IPaddress, 256 ); 
            break;
        }
    }
    return( playerIP );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x200474(%rip), %rdi    # 0x2153a0
callq 0xf829
leaq 0x1f37b8(%rip), %r14    # 0x2086f0
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0x14f63
addq $-0x190, %r15           # imm = 0xFE70
addq $0x190, %r14            # imm = 0x190
cmpq $-0xc800, %r15          # imm = 0xFFFF3800
jne 0x14f3b
jmp 0x14f85
leaq 0x1f3736(%rip), %rsi    # 0x2086a0
subq %r15, %rsi
addq $0xf0, %rsi
leaq 0x200425(%rip), %rdi    # 0x2153a0
movl $0x100, %edx            # imm = 0x100
callq 0xf384
leaq 0x200414(%rip), %rax    # 0x2153a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterDump
void rosterDump( int humanFlag, int npcFlag )
{
    int i, isNPC, isPrintable;

    for (i=0; i<ROSTER_MAX; i++) {
        if ( strlen( masterRoster[i].netID ) ) {
            isNPC = 0;
            isPrintable = 0;
            if (0==strcmp( masterRoster[i].netID, "0")) isNPC = 1;

            if (npcFlag && isNPC)    isPrintable = 1;
            if (humanFlag && !isNPC) isPrintable = 1;

            printf("%d::%s::%s::%s::%s::%s\n", 
                isPrintable,
                masterRoster[i].netID, 
                masterRoster[i].playerName,
                masterRoster[i].steamID,
                masterRoster[i].IPaddress,
                masterRoster[i].score );
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x1f3585(%rip), %r15    # 0x2086a0
leaq 0x97bc(%rip), %r14      # 0x1e8de
xorl %r12d, %r12d
movzbl (%r12,%r15), %ecx
testl %ecx, %ecx
je 0x1517a
movl %ebp, %eax
cmpl $0x30, %ecx
jne 0x15141
cmpb $0x0, 0x1(%r12,%r15)
movl %ebx, %eax
je 0x15141
movl %ebp, %eax
leaq (%r15,%r12), %rdx
xorl %esi, %esi
testl %eax, %eax
setne %sil
leaq 0x50(%r12,%r15), %rcx
leaq 0xa0(%r12,%r15), %r8
leaq 0xf0(%r12,%r15), %r9
leaq (%r12,%r15), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, (%rsp)
movq %r14, %rdi
xorl %eax, %eax
callq 0x8180
addq $0x190, %r12            # imm = 0x190
cmpq $0xc800, %r12           # imm = 0xC800
jne 0x15125
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParseCacheDestroyed
void rosterParseCacheDestroyed( char *destroyString, int maxChars, char *playerName, char *playerGUID, char *playerIP )
{
    char localBuffer[ 8092 ];         // EPIC size incresae
    char *p;

    strlcpy( localBuffer, destroyString, 8092 );  

    strclr( playerName );
    strclr( playerGUID );
    strclr( playerIP );

    // set p to point to start of destruct search string
    p = strstr( localBuffer, DESTROY1_STRING );
    if ( p == NULL ) 
        p = strstr( localBuffer, DESTROY2_STRING );

    if ( p != NULL ) { 
        // set p to point to start of player info
        p += strlen( DESTROY1_STRING );
    }

    if ( p != NULL ) { 
        if ( 0 != rosterFindFirstID(  p, '[', ']', playerGUID, maxChars )) { 
            strlcpy( playerIP,   rosterLookupIPFromGUID( playerGUID ), maxChars );
            strlcpy( playerName, rosterLookupNameFromGUID( playerGUID ), maxChars );
        }
    }

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1fa0, %rsp           # imm = 0x1FA0
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
movq %rsp, %r12
movl $0x1f9c, %edx           # imm = 0x1F9C
movq %r12, %rdi
callq 0xf384
movq %rbx, %rdi
callq 0xf829
movq %r14, %rdi
callq 0xf829
movq %r15, %rdi
callq 0xf829
leaq 0x9713(%rip), %rsi      # 0x1e8f6
movq %r12, %rdi
callq 0x83b0
testq %rax, %rax
jne 0x15204
leaq 0x972c(%rip), %rsi      # 0x1e923
movq %rsp, %rdi
callq 0x83b0
testq %rax, %rax
je 0x1525b
addq $0x2c, %rax
movq %rax, %rdi
movl $0x5b, %esi
movl $0x5d, %edx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x1441c
testl %eax, %eax
je 0x1525b
movq %r14, %rdi
callq 0x14d9f
movslq %ebp, %r12
leaq 0x1ffe6a(%rip), %rsi    # 0x2150a0
movq %r15, %rdi
movq %r12, %rdx
callq 0xf384
movq %r14, %rdi
callq 0x14d2d
leaq 0x1ffd50(%rip), %rsi    # 0x214fa0
movq %rbx, %rdi
movq %r12, %rdx
callq 0xf384
addq $0x1fa0, %rsp           # imm = 0x1FA0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParsePlayerSynthConn
void rosterParsePlayerSynthConn( char *connectString, int maxSize, char *playerName, char *playerGUID, char *playerIP )
{
    int i, j = 0, spaceCount = 0;

    // strlcpy( playerName, &connectString[ 45 ], maxSize );  // old code
    strlcpy( playerGUID, getWord( connectString, 1, " " ), maxSize );
    strlcpy( playerIP,   getWord( connectString, 2, " " ), maxSize );

    // look for 3rd <space> for beginning of player name
    // recoded for EPIC ID, also for WinGDK
    // 
    strclr( playerName );
    for (i=0; i < (int) strlen( connectString ); i++) {
        if ( connectString[i] == ' ' ) spaceCount++;
        if ( spaceCount == 3 ) {
            j = i + 1;
            break;
        }
    }
    if ( j != 0 ) strlcpy( playerName, &connectString[ j ], maxSize );

    logPrintf( LOG_LEVEL_DEBUG, "roster-synconn", "Connect String ::%s::\n", connectString);
    logPrintf( LOG_LEVEL_DEBUG, "roster-synconn", "Parsed String  ::%s::%s::%s::\n", playerName, playerGUID, playerIP );
    
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
leaq 0x6ec3(%rip), %rbx      # 0x1c14e
movl $0x1, %esi
movq %rbx, %rdx
callq 0xf82d
movslq %ebp, %rbp
movq %r14, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0xf384
movq %r12, %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq 0xf82d
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0xf384
movq %r15, %rdi
callq 0xf829
movq %r12, %rdi
callq 0x8120
testl %eax, %eax
jle 0x15315
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %esi
xorl %edx, %edx
cmpb $0x20, (%r12,%rcx)
sete %dl
addl %esi, %edx
cmpl $0x3, %edx
je 0x15301
incq %rcx
cmpq %rcx, %rax
jne 0x152e4
jmp 0x15315
movl %ecx, %eax
leaq (%r12,%rax), %rsi
incq %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0xf384
leaq 0x9634(%rip), %rbx      # 0x1e950
leaq 0x963c(%rip), %rdx      # 0x1e95f
movl $0x3, %edi
movq %rbx, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x1a3e3
leaq 0x963a(%rip), %rdx      # 0x1e976
movl $0x3, %edi
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a3e3
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParsePlayerSynthDisConn
void rosterParsePlayerSynthDisConn( char *connectString, int maxSize,  char *playerName, char *playerGUID, char *playerIP )
{
    int i, j = 0, spaceCount = 0;

    // strlcpy( playerName, &connectString[ 45 ], maxSize );  // old code
    strlcpy( playerGUID, getWord( connectString, 1, " " ), maxSize );
    strlcpy( playerIP,   getWord( connectString, 2, " " ), maxSize );

    // look for 3rd <space> for beginning of player name
    // recoded for EPIC ID, also for WinGDK
    // 
    strclr( playerName );
    for (i=0; i < (int) strlen( connectString ); i++) {
        if ( connectString[i] == ' ' ) spaceCount++;
        if ( spaceCount == 3 ) {
            j = i + 1;
            break;
        }
    }
    if ( j != 0 ) strlcpy( playerName, &connectString[ j ], maxSize );
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x6dcc(%rip), %r15      # 0x1c14e
movl $0x1, %esi
movq %r15, %rdx
callq 0xf82d
movslq %ebp, %rbp
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0xf384
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xf82d
movq %r12, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0xf384
movq %rbx, %rdi
callq 0xf829
movq %r14, %rdi
callq 0x8120
testl %eax, %eax
jle 0x153f6
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %esi
xorl %edx, %edx
cmpb $0x20, (%r14,%rcx)
sete %dl
addl %esi, %edx
cmpl $0x3, %edx
je 0x15405
incq %rcx
cmpq %rcx, %rax
jne 0x153db
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %eax
leaq (%r14,%rax), %rsi
incq %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf384
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParsePlayerConn
void rosterParsePlayerConn( char *connectString, int maxSize,  char *playerName, char *playerGUID, char *playerIP )
{
    // Refresh the roster from RCON first, THEN call this routine
    //
    char *w;

    // parse the log string for connect - only has playerName
    // Example:  [2019.07.26-01.45.36:776][792]LogNet: Join succeeded: PlayerName
    //
    w = strstr( connectString, "Join succeeded: " );
    if ( w != NULL ) {
        strlcpy( playerName, &w[ 16 ], maxSize );
        playerName[ strlen( playerName ) - 1] = 0;    // get rid of trailing LF/CR

        // Do a lookup of playerGUID and playerID
        //
        strlcpy( playerGUID, rosterLookupSteamIDFromName( playerName ), maxSize );
        strlcpy( playerIP,   rosterLookupIPFromName( playerName ), maxSize );
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
leaq 0x9554(%rip), %rsi      # 0x1e995
callq 0x83b0
testq %rax, %rax
je 0x154aa
addq $0x10, %rax
movslq %ebp, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xf384
movq %r14, %rdi
callq 0x8120
movb $0x0, -0x1(%r14,%rax)
movq %r14, %rdi
callq 0x14e14
leaq 0x1ffd23(%rip), %rsi    # 0x2151a0
movq %r15, %rdi
movq %r12, %rdx
callq 0xf384
movq %r14, %rdi
callq 0x14f1d
leaq 0x1fff09(%rip), %rsi    # 0x2153a0
movq %rbx, %rdi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf384
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParsePlayerDisConn
void rosterParsePlayerDisConn( char *connectString, int maxSize, char *playerName, char *playerGUID, char *playerIP )
{
    // Call this first THEN refresh the roster from RCON
    //
    char *w, *v;

    // parse the log string for disconnect - only has IP:port available
    // Example: [2019.07.26-01.47.06:457][106]LogNet: UChannel::Close: Sending CloseBunch. ChIndex == 0. 
    //     Name: [UChannel] ChIndex: 0, Closing: 0 [UNetConnection] RemoteAddr: 12.123.123.12:12345, 
    //     Name: IpConnection_3, Driver: GameNetDriver IpNetDriver_0, IsServer: YES, PC: INSPlayerController_2, 
    //     Owner: INSPlayerController_2, UniqueId: SteamNWI:UNKNOWN [0x7F6B5A5BC340]

    w = strstr( connectString, "RemoteAddr: " );
    if ( w != NULL ) {
        // extract player IP# (no port#)
        if ( NULL != ( v = getWord( w, 1, " :," ))) 
            strlcpy( playerIP, v, maxSize);
        else 
            strlcpy( playerIP, "", maxSize );

        // Do a lookup of playerGUID and playerName
        strlcpy( playerName, rosterLookupNameFromIP( playerIP ), maxSize );
        strlcpy( playerGUID, rosterLookupSteamIDFromName( playerName ), maxSize );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
leaq 0x94d9(%rip), %rsi      # 0x1e9a6
callq 0x83b0
testq %rax, %rax
je 0x15543
leaq 0x94d5(%rip), %rdx      # 0x1e9b3
movq %rax, %rdi
movl $0x1, %esi
callq 0xf82d
testq %rax, %rax
movslq %ebp, %r12
leaq 0x6211(%rip), %rsi      # 0x1b709
cmovneq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xf384
movq %r15, %rdi
callq 0x14cbb
leaq 0x1ff98a(%rip), %rsi    # 0x214ea0
movq %r14, %rdi
movq %r12, %rdx
callq 0xf384
movq %r14, %rdi
callq 0x14e14
leaq 0x1ffc70(%rip), %rsi    # 0x2151a0
movq %rbx, %rdi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf384
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParseSessionID
void rosterParseSessionID( char *sessionLogString, int maxChars, char *sessionID )
{
    char *w;
    int i, j;

    strclr( sessionID );
    w = strstr( sessionLogString, "SessionName:" );
    if ( w != NULL ) {
        strlcpy( sessionID, &w[13], maxChars );
        i = (int) strlen( sessionID );
        if ( i >= 1 )  {
            for (j = 0; j<i; j++)  {
                if ( sessionID[j] == 0x0d ) {
                    sessionID[j] = 0;
                    break;
                }
            }
        }
    }
    // if ( w != NULL ) strlcpy( sessionID, &w[13], 37 );

    return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0xf829
leaq 0x72e3(%rip), %rsi      # 0x1c9b8
movq %r14, %rdi
callq 0x83b0
testq %rax, %rax
je 0x1571b
addq $0xd, %rax
movslq %ebp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf384
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x1571b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb $0xd, (%rbx,%rcx)
je 0x15717
incq %rcx
cmpq %rcx, %rax
jne 0x15707
jmp 0x1571b
movb $0x0, (%rbx,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/roster.c
// Function: parseKillerKilled
static int _parseKillerKilled( char *killerKilled, int maxChars, char *playerName, char *playerID )
{
    char tmpStr[ 1024 ], *u = NULL, *w = NULL;
    int i, errCode;

    // -----------------
    // This local method parses "[clan]Player Name[12341234123]"  to playerName and playerID
    // -----------------

    strlcpy( tmpStr, killerKilled, 1024 );

    // Do a backward search and terminate the string at the last '['
    // which seprates player name from player ID.
    //
    errCode = 1;
    for (i = (int) strlen( tmpStr ); i>=1; i--) {
        if ( tmpStr[i] == '[' ) {
            w = &tmpStr[i];      // w is the pivot
            *w = 0;              // terminate this string in the middle
            errCode = 0;
            break;
        }
    }

    // Copy two substrings (first half, second half) to
    // respective return values, and get rid of [] surrounding
    // the player ID.
    //
    if ( errCode == 0 ) {
        errCode = 1;
        strlcpy( playerName, tmpStr, maxChars );
        strlcpy( playerID, w+1, maxChars );
        if ( NULL != ( u = strstr( playerID, "]" ))) {
            *u = 0;
            errCode = 0;
        }
    }
    return( errCode );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rsi
movq %rsp, %r12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
callq 0xf384
movq %r12, %rdi
callq 0x8120
movl $0x1, %ebp
testl %eax, %eax
jle 0x159e5
movl %eax, %ecx
cmpb $0x5b, (%rsp,%rcx)
je 0x159a2
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jge 0x15990
jmp 0x159e5
leaq (%rsp,%rcx), %r12
incq %r12
movb $0x0, -0x1(%r12)
movslq %r15d, %r15
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xf384
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf384
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x8170
testq %rax, %rax
je 0x159e5
movb $0x0, (%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piantirush.c
// Function: capRusherClear
static void _capRusherClear( void )
{
    int i;
    for (i = 0; i<SISSM_MAXPLAYERS; i++) {
        strclr( territorialRushers[i].playerCharID );        
        strclr( territorialRushers[i].playerName );
        territorialRushers[i].playerEarlyBreachCount = 0;
        territorialRushers[i].playerEarlyBreachCumulativeTime = 0;
        territorialRushers[i].playerIsInZone = 0;
    }

    kickArmed = 0;

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x209d70(%rip), %rbx    # 0x21fe90
movl $0x40, %r14d
movq %rbx, %rdi
callq 0xf829
leaq 0x40(%rbx), %rdi
callq 0xf829
movq $0x0, 0x80(%rbx)
movl $0x0, 0x88(%rbx)
addq $0x8c, %rbx
decq %r14
jne 0x16126
movb $0x0, 0x209ce1(%rip)    # 0x21fe40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushGameEndCB
int piantirushGameEndCB( char *strIn )
{
    // clear the training mode if "on", but not if "perm" - it is important to call this
    // before _startOfEverything() below.
    //
    if ( 1L == p2pGetL( "piantirush.p2p.training", 0L ) )  // check if "on", not "perm"
        p2pSetL( "piantirush.p2p.training", 0L );

    _captureSpeedForceNext();
    return 0;
}

// Assembly:
pushq %rax
leaq 0x5733(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x181e1
cmpq $0x1, %rax
jne 0x161f2
leaq 0x571f(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x180a5
movl $0xffffffff, 0x13ce8(%rip) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushRoundStartCB
int piantirushRoundStartCB( char *strIn )
{
    // Clear the 'last' objective letter ID 'A', 'B', 'C', etc.  -- this is used to suppress 
    // extra printing of fast prompt message to screen during counterattacks.
    //
    _lastObjLetter = '~';

    kickArmed = 0;
    _captureSpeedForceNext();
    _startOfEverything();
    alarmReset( dPtr, piantirushConfig.warnRusherDelaySec );

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

    // clear the cumulative territorial zone antirush data structure
    //
    _capRusherClear();


    // if in training mode, announce it
    //
    if ( 0L != p2pGetL( "piantirush.p2p.training", 0L ) )  
       apiSay( piantirushConfig.trainingModeMsg );

    // clear the bot-spawnkill detector timer
    //
    alarmCancel( sPtr );

    return 0;
}

// Assembly:
pushq %rbx
movb $0x7e, 0x13cc8(%rip)    # 0x29ed0
movb $0x0, 0x209c31(%rip)    # 0x21fe40
movl $0xffffffff, 0x13ccb(%rip) # imm = 0xFFFFFFFF
callq 0x15ba8
movq 0x209c23(%rip), %rdi    # 0x21fe48
movslq 0x204288(%rip), %rsi    # 0x21a4b4
callq 0xfc98
callq 0x14563
leaq 0x8c8f(%rip), %rsi      # 0x1eecc
movq %rax, %rdi
callq 0x83b0
movq 0x209c04(%rip), %rbx    # 0x21fe50
testq %rax, %rax
je 0x1626a
movq 0x2096c8(%rip), %rdi    # 0x21f920
callq 0xfcc3
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfc98
jmp 0x16272
movq %rbx, %rdi
callq 0xfcb9
callq 0x16115
leaq 0x568c(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x181e1
testq %rax, %rax
je 0x16298
leaq 0x207673(%rip), %rdi    # 0x21d904
xorl %eax, %eax
callq 0x13337
movq 0x209b99(%rip), %rdi    # 0x21fe38
callq 0xfcb9
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piantirush.c
// Function: localSay
static int _localSay( const char * format, ... )
{
    static char buffer[API_T_BUFSIZE];
    int errCode = 0;
    char *v;

    // 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 ( 0 == _localMute ) {
        va_list args;
        va_start( args, format );
        vsnprintf( buffer, (API_T_BUFSIZE >= API_MAXSAY) ? API_MAXSAY : API_T_BUFSIZE, format, args );
        errCode = apiSay( buffer );
        va_end (args);
    }
    return errCode;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x167fa
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x13dc1
movq %rax, %r14
leaq 0x67aa(%rip), %rsi      # 0x1cfb3
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x16828
leaq 0x57db(%rip), %rsi      # 0x1bff7
movq %r14, %rdi
callq 0x8220
testl %eax, %eax
jne 0x16877
cmpb $0x0, 0x209639(%rip)    # 0x21fe68
jne 0x16877
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x20b933(%rip), %r14    # 0x222190
movl $0x50, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x80c0
movq %r14, %rdi
xorl %eax, %eax
callq 0x13337
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushSigKillCB
int piantirushSigKillCB( char *strIn )
{
    logPrintf( LOG_LEVEL_INFO, "piantirush", "Restoring Normal Capture Rate before shutdown" );

    _captureSpeedForceNext();
    _captureSpeed( 0 );

    return 0;
}

// Assembly:
pushq %rax
leaq 0x8248(%rip), %rsi      # 0x1ead2
leaq 0x8325(%rip), %rdx      # 0x1ebb6
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a3e3
movl $0xffffffff, 0x1363d(%rip) # imm = 0xFFFFFFFF
xorl %edi, %edi
callq 0x15ce2
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20958e(%rip), %rdi    # 0x21fe48
movslq 0x203bf3(%rip), %rsi    # 0x21a4b4
callq 0xfc98
callq 0x16115
callq 0x14563
leaq 0x85f5(%rip), %rsi      # 0x1eecc
movq %rax, %rdi
callq 0x83b0
movq 0x20956a(%rip), %rbx    # 0x21fe50
testq %rax, %rax
je 0x16904
movq 0x20902e(%rip), %rdi    # 0x21f920
callq 0xfcc3
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfc98
jmp 0x1690c
movq %rbx, %rdi
callq 0xfcb9
movl $0xffffffff, 0x135c6(%rip) # imm = 0xFFFFFFFF
movl $0x2, 0x135c0(%rip)     # 0x29ee0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15197
cmpl $0x0, 0x203b68(%rip)    # 0x21a4b8
je 0x169dd
testb $0x1, 0x20950f(%rip)    # 0x21fe6c
jne 0x169dd
movq 0x208fba(%rip), %rdi    # 0x21f920
callq 0xfcc3
movslq 0x204f4e(%rip), %rcx    # 0x21b8c0
cmpq %rcx, %rax
jl 0x169dd
cmpl $0x0, 0x13562(%rip)     # 0x29ee0
je 0x169dd
testb $0x1, 0x2094b9(%rip)    # 0x21fe40
je 0x169dd
leaq 0x204730(%rip), %rdx    # 0x21b0c0
leaq 0x100(%rsp), %rdi
movq %rsp, %rsi
callq 0x16a27
testl %eax, %eax
jne 0x169dd
leaq 0x8127(%rip), %rsi      # 0x1ead2
leaq 0x8232(%rip), %rdx      # 0x1ebe4
leaq 0x100(%rsp), %rbx
movq %rsp, %r8
movl $0x1, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a3e3
leaq 0x8240(%rip), %rdi      # 0x1ec13
movq %rbx, %rsi
xorl %eax, %eax
callq 0x16799
movb $0x0, 0x20945c(%rip)    # 0x21fe40
movslq 0x207721(%rip), %rsi    # 0x21e10c
testq %rsi, %rsi
je 0x16a1c
movq 0x209441(%rip), %rdi    # 0x21fe38
callq 0xfc98
movl 0x20770a(%rip), %ecx    # 0x21e10c
leaq 0x80c9(%rip), %rsi      # 0x1ead2
leaq 0x8220(%rip), %rdx      # 0x1ec30
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a3e3
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x552a(%rip), %rdi      # 0x1bf6c
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x181e1
movq %rax, %r13
callq 0x13dc1
movq %rax, %rbp
leaq 0x6555(%rip), %rsi      # 0x1cfb3
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x16a7d
leaq 0x5586(%rip), %rsi      # 0x1bff7
movq %rbp, %rdi
callq 0x8220
testl %eax, %eax
jne 0x16af0
testq %r13, %r13
je 0x16aaa
leaq 0x8049(%rip), %rsi      # 0x1ead2
leaq 0x8d9d(%rip), %rdx      # 0x1f82d
movl $0x2, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1a3e3
movl $0x1, %r12d
jmp 0x16af0
cmpb $0x0, (%r14)
je 0x16abd
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13676
cmpb $0x0, (%rbx)
je 0x16acd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13789
leaq 0x7ffe(%rip), %rsi      # 0x1ead2
leaq 0x8d39(%rip), %rdx      # 0x1f814
xorl %r12d, %r12d
movl $0x3, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1a3e3
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_O3/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 0x208dfb(%rip), %rdi    # 0x21fe50
callq 0xfcc3
cmpq $0x6, %rax
jl 0x171ab
leaq 0x6f5f(%rip), %rsi      # 0x1dfca
movq %rbx, %rdi
callq 0x83b0
testq %rax, %rax
je 0x171ab
leaq 0xc0(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xf384
leaq 0x7bc9(%rip), %rdx      # 0x1ec64
movq %r14, %rdi
xorl %esi, %esi
callq 0xf82d
testq %rax, %rax
je 0x171ab
movq %rsp, %rdi
movl $0x40, %edx
movq %rax, %rsi
callq 0xf384
callq 0x1455b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x83b0
testq %rax, %rax
je 0x171ab
movq %rsp, %rdi
callq 0x11e94
leaq 0x80(%rsp), %rbx
movl $0x40, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf384
cmpb $0x0, (%rbx)
je 0x171ab
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl $0x40, %edx
callq 0xf384
cmpl $0x0, 0x12dc2(%rip)     # 0x29ee0
je 0x1713c
testb $0x1, 0x208d19(%rip)    # 0x21fe40
je 0x1713c
leaq 0x205fa8(%rip), %rdx    # 0x21d0d8
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x16e97
xorl %r14d, %r14d
leaq 0x208d4a(%rip), %r15    # 0x21fe90
movq %rsp, %rbx
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x8220
testl %eax, %eax
je 0x17182
addq $0x8c, %r14
cmpq $0x2300, %r14           # imm = 0x2300
jne 0x17149
leaq 0x7962(%rip), %rsi      # 0x1ead2
leaq 0x8751(%rip), %rdx      # 0x1f8c8
xorl %edi, %edi
xorl %eax, %eax
callq 0x1a3e3
jmp 0x171ab
movl $0x0, 0x88(%r14,%r15)
leaq 0x793d(%rip), %rsi      # 0x1ead2
leaq 0x870d(%rip), %rdx      # 0x1f8a9
movq %rsp, %rcx
movl $0x3, %edi
xorl %eax, %eax
callq 0x1a3e3
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1221a(%rip)     # 0x29ee4
xorl %edi, %edi
callq 0x15ce2
movl %ebx, 0x1220d(%rip)     # 0x29ee4
leaq 0x6df4(%rip), %rsi      # 0x1ead2
leaq 0x7c30(%rip), %rdx      # 0x1f915
movl $0x3, %edi
xorl %eax, %eax
callq 0x1a3e3
movb $0x0, 0x208148(%rip)    # 0x21fe40
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf829
callq 0x14563
movq %rax, %rbx
leaq 0x41b7(%rip), %rsi      # 0x1bed2
movq %rax, %rdi
callq 0x8350
testq %rax, %rax
je 0x17d3c
leaq 0x202385(%rip), %rsi    # 0x21a0b4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf384
leaq 0x419b(%rip), %rsi      # 0x1bede
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0x17d64
leaq 0x201f5d(%rip), %rsi    # 0x219cb4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf384
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x16799
cmpb $0x0, (%rbx)
je 0x17d7d
movb $0x1, 0x2080c3(%rip)    # 0x21fe40
cmpb $0x1, 0x2080e8(%rip)    # 0x21fe6c
jne 0x17d8d
movb $0x0, 0x2080b3(%rip)    # 0x21fe40
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x202719(%rip)    # 0x21a4b8
je 0x17dcd
pushq %rax
callq 0x14563
leaq 0x6d7d(%rip), %rsi      # 0x1eb2b
movq %rax, %rdi
callq 0x83b0
testq %rax, %rax
je 0x17dc9
leaq 0x202efe(%rip), %rdi    # 0x21acc0
xorl %eax, %eax
callq 0x16799
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17f55
testl %eax, %eax
je 0x17e2f
movq 0x207b3f(%rip), %rdi    # 0x21f920
callq 0xfcc3
movslq 0x2026cf(%rip), %rcx    # 0x21a4bc
movslq 0x205b04(%rip), %rdx    # 0x21d8f8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x17e26
leaq 0x2026bd(%rip), %rdi    # 0x21a4c0
xorl %eax, %eax
callq 0x16799
movb $0x0, 0x20802f(%rip)    # 0x21fe40
movq 0x207b08(%rip), %rdi    # 0x21f920
callq 0xfcb9
xorl %edi, %edi
callq 0x15ce2
jmp 0x17e50
leaq 0x202a93(%rip), %rdi    # 0x21a8c0
jmp 0x17e49
leaq 0x3ad4(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x181e1
testq %rax, %rax
je 0x17dda
leaq 0x205ebb(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x16799
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17f55
testl %eax, %eax
je 0x17eb2
movq 0x207ab8(%rip), %rdi    # 0x21f920
callq 0xfcc3
movslq 0x204258(%rip), %rcx    # 0x21c0cc
movslq 0x205a75(%rip), %rdx    # 0x21d8f0
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x17ea9
leaq 0x203a42(%rip), %rdi    # 0x21b8cc
xorl %eax, %eax
callq 0x16799
movq 0x207a88(%rip), %rdi    # 0x21f920
movl $0x2, %esi
callq 0xfc98
callq 0x16115
jmp 0x17ed3
leaq 0x203e1c(%rip), %rdi    # 0x21bccc
jmp 0x17ecc
leaq 0x3a51(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x181e1
testq %rax, %rax
je 0x17e61
leaq 0x205e38(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x16799
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2061a8(%rip), %r14    # 0x21e108
movl $0x1, %ebx
testq %r14, %r14
je 0x17f88
addq 0x207ebf(%rip), %r14    # 0x21fe30
callq 0x117c0
cmpq %rax, %r14
jbe 0x17f88
xorl %ebx, %ebx
cmpq $0x0, 0x207eab(%rip)    # 0x21fe30
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20c97e(%rip), %r15    # 0x224990
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x1809a
incq %rbx
subq $-0x80, %r15
cmpq $0x100, %rbx            # imm = 0x100
jne 0x18014
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %ebp, %ebp
je 0x1809a
leaq 0x21494d(%rip), %r15    # 0x22c990
leaq 0x20c946(%rip), %rdi    # 0x224990
xorl %r12d, %r12d
movl $0x80, %eax
cmpb $0x0, (%rdi)
je 0x18082
incq %r12
addq %rax, %r15
addq %rax, %rdi
cmpq $0x100, %r12            # imm = 0x100
jne 0x18052
leaq 0x7978(%rip), %rsi      # 0x1f9e8
leaq 0x7975(%rip), %rdx      # 0x1f9ec
xorl %edi, %edi
xorl %eax, %eax
callq 0x1a3e3
jmp 0x1809a
movl $0x80, %edx
movq %r14, %rsi
callq 0xf384
movq %r15, %rdi
callq 0xf829
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, (%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x20c810(%rip), %r14    # 0x224990
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8220
testl %eax, %eax
je 0x181aa
addq $-0x80, %r15
subq $-0x80, %r14
cmpq $-0x8000, %r15          # imm = 0x8000
jne 0x18183
movsd (%rsp), %xmm0
jmp 0x181d7
leaq 0x2147df(%rip), %rdi    # 0x22c990
subq %r15, %rdi
leaq 0x4edd(%rip), %rsi      # 0x1d098
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
movsd (%rsp), %xmm0
jne 0x181d7
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
xorl %r15d, %r15d
leaq 0x20c793(%rip), %r12    # 0x224990
leaq (%r12,%r15), %rsi
movq %r14, %rdi
callq 0x8220
testl %eax, %eax
je 0x1821c
subq $-0x80, %r15
cmpq $0x8000, %r15           # imm = 0x8000
jne 0x181fd
jmp 0x18247
leaq 0x21476d(%rip), %rdi    # 0x22c990
cmpb $0x0, (%r15,%rdi)
je 0x18247
addq %r15, %rdi
leaq 0x7754(%rip), %rsi      # 0x1f988
movq %rsp, %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
jne 0x18247
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20c725(%rip), %r15    # 0x224990
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x18290
addq $-0x80, %r12
subq $-0x80, %r15
cmpq $-0x8000, %r12          # imm = 0x8000
jne 0x1826e
jmp 0x1829a
leaq 0x2146f9(%rip), %rbx    # 0x22c990
subq %r12, %rbx
leaq 0x21c6ef(%rip), %r14    # 0x234990
movl $0x80, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf384
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq