LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
jge 0x13f49
leaq 0x20135e(%rip), %rdi    # 0x2152a0
callq 0xed98
jmp 0x13fa8
leaq 0x201350(%rip), %rdi    # 0x2152a0
callq 0xed98
leaq 0x1f4794(%rip), %rdi    # 0x2086f0
xorl %r14d, %r14d
addq $-0x190, %r14           # imm = 0xFE70
cmpq $-0xc990, %r14          # imm = 0xFFFF3670
je 0x13f3b
leaq 0x190(%rdi), %r15
movq %rbx, %rsi
callq 0x8360
movq %r15, %rdi
testq %rax, %rax
je 0x13f5f
leaq 0x1f4713(%rip), %rsi    # 0x2086a0
subq %r14, %rsi
addq $-0xf0, %rsi
leaq 0x201302(%rip), %rdi    # 0x2152a0
movl $0x100, %edx            # imm = 0x100
callq 0xe97a
leaq 0x2012f1(%rip), %rax    # 0x2152a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2013d7(%rip), %rdi    # 0x2153a0
callq 0xed98
leaq 0x1f471b(%rip), %rdi    # 0x2086f0
xorl %r14d, %r14d
addq $-0x190, %r14           # imm = 0xFE70
cmpq $-0xc990, %r14          # imm = 0xFFFF3670
je 0x14020
leaq 0x190(%rdi), %r15
movq %rbx, %rsi
callq 0x8220
movq %r15, %rdi
testl %eax, %eax
jne 0x13fd8
leaq 0x1f469b(%rip), %rsi    # 0x2086a0
subq %r14, %rsi
addq $-0xa0, %rsi
leaq 0x20138a(%rip), %rdi    # 0x2153a0
movl $0x100, %edx            # imm = 0x100
callq 0xe97a
leaq 0x201379(%rip), %rax    # 0x2153a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f44e4(%rip), %r15    # 0x2086a0
leaq 0x970b(%rip), %r14      # 0x1d8ce
xorl %r12d, %r12d
cmpq $0xc800, %r12           # imm = 0xC800
je 0x1422d
movzbl (%r12,%r15), %ecx
testl %ecx, %ecx
je 0x14224
movl %ebp, %eax
cmpl $0x30, %ecx
jne 0x141eb
cmpb $0x0, 0x1(%r12,%r15)
movl %ebx, %eax
je 0x141eb
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
jmp 0x141c6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe97a
movq %rbx, %rdi
callq 0xed98
movq %r14, %rdi
callq 0xed98
movq %r15, %rdi
callq 0xed98
leaq 0x9660(%rip), %rsi      # 0x1d8e6
movq %r12, %rdi
callq 0x83c0
testq %rax, %rax
jne 0x142a7
leaq 0x9679(%rip), %rsi      # 0x1d913
movq %rsp, %rdi
callq 0x83c0
testq %rax, %rax
je 0x142fa
addq $0x2c, %rax
pushq $0x5b
popq %rsi
pushq $0x5d
popq %rdx
movq %rax, %rdi
movq %r14, %rcx
movl %ebp, %r8d
callq 0x1351b
testl %eax, %eax
je 0x142fa
movq %r14, %rdi
callq 0x13e40
movslq %ebp, %r12
leaq 0x200dcb(%rip), %rsi    # 0x2150a0
movq %r15, %rdi
movq %r12, %rdx
callq 0xe97a
movq %r14, %rdi
callq 0x13dcd
leaq 0x200cb1(%rip), %rsi    # 0x214fa0
movq %rbx, %rdi
movq %r12, %rdx
callq 0xe97a
addq $0x1fa0, %rsp           # imm = 0x1FA0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
leaq 0x6e21(%rip), %rdx      # 0x1b14e
pushq $0x1
popq %rsi
callq 0xed9c
movslq %ebp, %r13
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xe97a
pushq $0x2
popq %rsi
movq %r12, %rdi
leaq 0x6df6(%rip), %rdx      # 0x1b14e
callq 0xed9c
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %r14
movq %rax, %rsi
movq %r13, %rdx
callq 0xe97a
movq %rbx, %rdi
callq 0xed98
movq %r12, %rdi
callq 0x8120
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leaq 0x1(%r12), %rsi
subq $0x1, %rax
jb 0x143b5
xorl %edx, %edx
cmpb $0x20, -0x1(%rsi)
sete %dl
addl %edx, %ecx
cmpl $0x3, %ecx
je 0x143aa
incq %rsi
jmp 0x1438f
movq %r14, %rdi
movq %r13, %rdx
callq 0xe97a
leaq 0x9584(%rip), %rbx      # 0x1d940
leaq 0x958c(%rip), %rdx      # 0x1d94f
pushq $0x3
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x1920b
leaq 0x958a(%rip), %rdx      # 0x1d966
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1920b
// File: /workspace/github_c_makefile_star2_O2/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 0x6d2b(%rip), %rdx      # 0x1b14e
pushq $0x1
popq %rsi
callq 0xed9c
movslq %ebp, %r15
movq %r13, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe97a
pushq $0x2
popq %rsi
movq %r14, %rdi
leaq 0x6d05(%rip), %rdx      # 0x1b14e
callq 0xed9c
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe97a
movq %rbx, %rdi
callq 0xed98
movq %r14, %rdi
callq 0x8120
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
incq %r14
subq $0x1, %rax
jb 0x144a9
xorl %edx, %edx
cmpb $0x20, -0x1(%r14)
sete %dl
addl %edx, %ecx
cmpl $0x3, %ecx
jne 0x14473
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe97a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94b3(%rip), %rsi      # 0x1d985
callq 0x83c0
testq %rax, %rax
je 0x1453b
addq $0x10, %rax
movslq %ebp, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xe97a
movq %r14, %rdi
callq 0x8120
movb $0x0, -0x1(%r14,%rax)
movq %r14, %rdi
callq 0x13eb3
leaq 0x200c92(%rip), %rsi    # 0x2151a0
movq %r15, %rdi
movq %r12, %rdx
callq 0xe97a
movq %r14, %rdi
callq 0x13fba
leaq 0x200e78(%rip), %rsi    # 0x2153a0
movq %rbx, %rdi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe97a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9438(%rip), %rsi      # 0x1d996
callq 0x83c0
testq %rax, %rax
je 0x145d2
leaq 0x9434(%rip), %rdx      # 0x1d9a3
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xed9c
testq %rax, %rax
movslq %ebp, %r12
leaq 0x6182(%rip), %rsi      # 0x1a709
cmovneq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xe97a
movq %r15, %rdi
callq 0x13d5a
leaq 0x2008fb(%rip), %rsi    # 0x214ea0
movq %r14, %rdi
movq %r12, %rdx
callq 0xe97a
movq %r14, %rdi
callq 0x13eb3
leaq 0x200be1(%rip), %rsi    # 0x2151a0
movq %rbx, %rdi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe97a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xed98
leaq 0x7273(%rip), %rsi      # 0x1b9c0
movq %r14, %rdi
callq 0x83c0
testq %rax, %rax
je 0x14796
addq $0xd, %rax
movslq %ebp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe97a
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x14796
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x14796
leaq 0x1(%rcx), %rdx
cmpb $0xd, (%rbx,%rcx)
movq %rdx, %rcx
jne 0x1477f
movb $0x0, -0x1(%rbx,%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe97a
movq %r12, %rdi
callq 0x8120
pushq $0x1
popq %rbp
testl %eax, %eax
jle 0x14a4c
movl %eax, %ecx
decl %eax
cmpb $0x5b, (%rsp,%rcx)
jne 0x149fd
leaq (%rsp,%rcx), %r12
incq %r12
movb $0x0, -0x1(%r12)
movslq %r15d, %r15
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xe97a
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe97a
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x8170
testq %rax, %rax
je 0x14a4c
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_O2/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
pushq $0x40
popq %r14
leaq 0x20ad3e(%rip), %rbx    # 0x21fe90
subq $0x1, %r14
jb 0x15181
movq %rbx, %rdi
callq 0xed98
leaq 0x40(%rbx), %rdi
callq 0xed98
andq $0x0, 0x80(%rbx)
andl $0x0, 0x88(%rbx)
addq $0x8c, %rbx
jmp 0x15152
movb $0x0, 0x20acb8(%rip)    # 0x21fe40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5712(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17172
cmpq $0x1, %rax
jne 0x15213
leaq 0x56fe(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17049
orl $-0x1, 0x14cca(%rip)    # 0x29ee4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x14caa(%rip)    # 0x29ed0
movb $0x0, 0x20ac13(%rip)    # 0x21fe40
orl $-0x1, 0x14cb0(%rip)    # 0x29ee4
callq 0x14c08
movq 0x20ac08(%rip), %rdi    # 0x21fe48
movslq 0x20526d(%rip), %rsi    # 0x21a4b4
callq 0xf1b1
callq 0x13648
leaq 0x8c5c(%rip), %rsi      # 0x1deb4
movq %rax, %rdi
callq 0x83c0
movq 0x20abe9(%rip), %rbx    # 0x21fe50
testq %rax, %rax
je 0x15285
movq 0x20a6ad(%rip), %rdi    # 0x21f920
callq 0xf1d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf1b1
jmp 0x1528d
movq %rbx, %rdi
callq 0xf1d2
callq 0x15143
leaq 0x5671(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17172
testq %rax, %rax
je 0x152b3
leaq 0x208658(%rip), %rdi    # 0x21d904
xorl %eax, %eax
callq 0x125a8
movq 0x20ab7e(%rip), %rdi    # 0x21fe38
callq 0xf1d2
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x157fc
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 0x12f75
movq %rax, %r14
leaq 0x67b0(%rip), %rsi      # 0x1bfbb
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x1582a
leaq 0x57d9(%rip), %rsi      # 0x1aff7
movq %r14, %rdi
callq 0x8220
testl %eax, %eax
jne 0x15877
cmpb $0x0, 0x20a637(%rip)    # 0x21fe68
jne 0x15877
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 0x20c931(%rip), %r14    # 0x222190
pushq $0x50
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x80c0
movq %r14, %rdi
xorl %eax, %eax
callq 0x125a8
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8230(%rip), %rsi      # 0x1daba
leaq 0x830d(%rip), %rdx      # 0x1db9e
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1920b
orl $-0x1, 0x14642(%rip)    # 0x29ee4
xorl %edi, %edi
callq 0x14d3e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20a593(%rip), %rdi    # 0x21fe48
movslq 0x204bf8(%rip), %rsi    # 0x21a4b4
callq 0xf1b1
callq 0x15143
callq 0x13648
leaq 0x85e2(%rip), %rsi      # 0x1deb4
movq %rax, %rdi
callq 0x83c0
movq 0x20a56f(%rip), %rbx    # 0x21fe50
testq %rax, %rax
je 0x158ff
movq 0x20a033(%rip), %rdi    # 0x21f920
callq 0xf1d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf1b1
jmp 0x15907
movq %rbx, %rdi
callq 0xf1d2
orl $-0x1, 0x145ce(%rip)    # 0x29edc
movl $0x2, 0x145c8(%rip)     # 0x29ee0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1423a
cmpl $0x0, 0x204b70(%rip)    # 0x21a4b8
je 0x159d3
testb $0x1, 0x20a517(%rip)    # 0x21fe6c
jne 0x159d3
movq 0x209fc2(%rip), %rdi    # 0x21f920
callq 0xf1d9
movslq 0x205f56(%rip), %rcx    # 0x21b8c0
cmpq %rcx, %rax
jl 0x159d3
cmpl $0x0, 0x1456a(%rip)     # 0x29ee0
je 0x159d3
testb $0x1, 0x20a4c1(%rip)    # 0x21fe40
je 0x159d3
leaq 0x205738(%rip), %rdx    # 0x21b0c0
leaq 0x100(%rsp), %rdi
movq %rsp, %rsi
callq 0x15a1b
testl %eax, %eax
jne 0x159d3
leaq 0x8117(%rip), %rsi      # 0x1daba
leaq 0x8222(%rip), %rdx      # 0x1dbcc
pushq $0x1
popq %rdi
leaq 0x100(%rsp), %rbx
movq %rsp, %r8
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1920b
leaq 0x8232(%rip), %rdi      # 0x1dbfb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1579b
movb $0x0, 0x20a466(%rip)    # 0x21fe40
movslq 0x20872b(%rip), %rsi    # 0x21e10c
testq %rsi, %rsi
je 0x15a10
movq 0x20a44b(%rip), %rdi    # 0x21fe38
callq 0xf1b1
movl 0x208714(%rip), %ecx    # 0x21e10c
leaq 0x80bb(%rip), %rsi      # 0x1daba
leaq 0x8212(%rip), %rdx      # 0x1dc18
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1920b
xorl %eax, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5536(%rip), %rdi      # 0x1af6c
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x17172
movq %rax, %r13
callq 0x12f75
movq %rax, %rbp
leaq 0x6569(%rip), %rsi      # 0x1bfbb
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0x15a71
leaq 0x5592(%rip), %rsi      # 0x1aff7
movq %rbp, %rdi
callq 0x8220
testl %eax, %eax
jne 0x15ade
testq %r13, %r13
je 0x15a9a
leaq 0x803d(%rip), %rsi      # 0x1daba
leaq 0x8d91(%rip), %rdx      # 0x1e815
pushq $0x2
popq %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1920b
pushq $0x1
popq %r12
jmp 0x15ade
cmpb $0x0, (%r14)
je 0x15aad
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x128e1
cmpb $0x0, (%rbx)
je 0x15abd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x129f0
leaq 0x7ff6(%rip), %rsi      # 0x1daba
leaq 0x8d31(%rip), %rdx      # 0x1e7fc
xorl %r12d, %r12d
pushq $0x3
popq %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1920b
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_O2/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 0x209e20(%rip), %rdi    # 0x21fe50
callq 0xf1d9
cmpq $0x6, %rax
jl 0x1617b
leaq 0x6f74(%rip), %rsi      # 0x1cfba
movq %rbx, %rdi
callq 0x83c0
testq %rax, %rax
je 0x1617b
leaq 0xc0(%rsp), %r14
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe97a
leaq 0x7bd8(%rip), %rdx      # 0x1dc4c
movq %r14, %rdi
xorl %esi, %esi
callq 0xed9c
testq %rax, %rax
je 0x1617b
movq %rsp, %rdi
pushq $0x40
popq %rdx
movq %rax, %rsi
callq 0xe97a
callq 0x13640
movq %rbx, %rdi
movq %rax, %rsi
callq 0x83c0
testq %rax, %rax
je 0x1617b
movq %rsp, %rdi
callq 0x111d9
leaq 0x80(%rsp), %rbx
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe97a
cmpb $0x0, (%rbx)
je 0x1617b
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
pushq $0x40
popq %rdx
callq 0xe97a
cmpl $0x0, 0x13def(%rip)     # 0x29ee0
je 0x1610f
testb $0x1, 0x209d46(%rip)    # 0x21fe40
je 0x1610f
leaq 0x206fd5(%rip), %rdx    # 0x21d0d8
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x15e75
xorl %r14d, %r14d
leaq 0x209d77(%rip), %r15    # 0x21fe90
movq %rsp, %rbx
cmpq $0x2300, %r14           # imm = 0x2300
je 0x1613e
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x8220
testl %eax, %eax
je 0x16157
addq $0x8c, %r14
jmp 0x1611c
leaq 0x7975(%rip), %rsi      # 0x1daba
leaq 0x8764(%rip), %rdx      # 0x1e8b0
xorl %edi, %edi
xorl %eax, %eax
callq 0x1920b
jmp 0x1617b
andl $0x0, 0x88(%r14,%r15)
leaq 0x7953(%rip), %rsi      # 0x1daba
leaq 0x8723(%rip), %rdx      # 0x1e891
pushq $0x3
popq %rdi
movq %rsp, %rcx
xorl %eax, %eax
callq 0x1920b
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
orl $-0x1, 0x1326d(%rip)    # 0x29ee4
xorl %edi, %edi
callq 0x14d3e
orl $-0x1, 0x1325f(%rip)    # 0x29ee4
leaq 0x6e2e(%rip), %rsi      # 0x1daba
leaq 0x7c6a(%rip), %rdx      # 0x1e8fd
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x1920b
movb $0x0, 0x20919c(%rip)    # 0x21fe40
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xed98
callq 0x13648
movq %rax, %rbx
leaq 0x420b(%rip), %rsi      # 0x1aed2
movq %rax, %rdi
callq 0x8360
testq %rax, %rax
je 0x16ce8
leaq 0x2033d9(%rip), %rsi    # 0x21a0b4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xe97a
leaq 0x41ef(%rip), %rsi      # 0x1aede
movq %rbx, %rdi
callq 0x8360
testq %rax, %rax
je 0x16d10
leaq 0x202fb1(%rip), %rsi    # 0x219cb4
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xe97a
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1579b
cmpb $0x0, (%rbx)
je 0x16d29
movb $0x1, 0x209117(%rip)    # 0x21fe40
cmpb $0x1, 0x20913c(%rip)    # 0x21fe6c
jne 0x16d39
movb $0x0, 0x209107(%rip)    # 0x21fe40
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x20376d(%rip)    # 0x21a4b8
je 0x16d79
pushq %rax
callq 0x13648
leaq 0x6db9(%rip), %rsi      # 0x1db13
movq %rax, %rdi
callq 0x83c0
testq %rax, %rax
je 0x16d75
leaq 0x203f52(%rip), %rdi    # 0x21acc0
xorl %eax, %eax
callq 0x1579b
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16efd
testl %eax, %eax
je 0x16ddb
movq 0x208b93(%rip), %rdi    # 0x21f920
callq 0xf1d9
movslq 0x203723(%rip), %rcx    # 0x21a4bc
movslq 0x206b58(%rip), %rdx    # 0x21d8f8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x16dd2
leaq 0x203711(%rip), %rdi    # 0x21a4c0
xorl %eax, %eax
callq 0x1579b
movb $0x0, 0x209083(%rip)    # 0x21fe40
movq 0x208b5c(%rip), %rdi    # 0x21f920
callq 0xf1d2
xorl %edi, %edi
callq 0x14d3e
jmp 0x16dfc
leaq 0x203ae7(%rip), %rdi    # 0x21a8c0
jmp 0x16df5
leaq 0x3b28(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17172
testq %rax, %rax
je 0x16d86
leaq 0x206f0f(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x1579b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16efd
testl %eax, %eax
je 0x16e5c
movq 0x208b0c(%rip), %rdi    # 0x21f920
callq 0xf1d9
movslq 0x2052ac(%rip), %rcx    # 0x21c0cc
movslq 0x206ac9(%rip), %rdx    # 0x21d8f0
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x16e53
leaq 0x204a96(%rip), %rdi    # 0x21b8cc
xorl %eax, %eax
callq 0x1579b
movq 0x208adc(%rip), %rdi    # 0x21f920
pushq $0x2
popq %rsi
callq 0xf1b1
callq 0x15143
jmp 0x16e7d
leaq 0x204e72(%rip), %rdi    # 0x21bccc
jmp 0x16e76
leaq 0x3aa7(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17172
testq %rax, %rax
je 0x16e0d
leaq 0x206e8e(%rip), %rdi    # 0x21dd04
xorl %eax, %eax
callq 0x1579b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x207200(%rip), %r14    # 0x21e108
pushq $0x1
popq %rbx
testq %r14, %r14
je 0x16f2e
addq 0x208f19(%rip), %r14    # 0x21fe30
callq 0x10b6a
cmpq %rax, %r14
jbe 0x16f2e
xorl %ebx, %ebx
cmpq $0x0, 0x208f05(%rip)    # 0x21fe30
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20d9dc(%rip), %r15    # 0x224990
xorl %ebx, %ebx
cmpq $0x100, %rbx            # imm = 0x100
je 0x16fd7
movq %r14, %rdi
movq %r15, %rsi
callq 0x8220
testl %eax, %eax
je 0x1703e
incq %rbx
subq $-0x80, %r15
jmp 0x16fb6
pushq $-0x1
popq %rbx
testl %ebp, %ebp
je 0x1703e
leaq 0x2159ab(%rip), %r15    # 0x22c990
leaq 0x20d9a4(%rip), %rdi    # 0x224990
xorl %r12d, %r12d
movl $0x80, %eax
cmpq $0x100, %r12            # imm = 0x100
je 0x1700d
cmpb $0x0, (%rdi)
je 0x17026
incq %r12
addq %rax, %r15
addq %rax, %rdi
jmp 0x16ff4
leaq 0x79bc(%rip), %rsi      # 0x1e9d0
leaq 0x79b9(%rip), %rdx      # 0x1e9d4
xorl %edi, %edi
xorl %eax, %eax
callq 0x1920b
jmp 0x1703e
movl $0x80, %edx
movq %r14, %rsi
callq 0xe97a
movq %r15, %rdi
callq 0xed98
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
xorl %esi, %esi
callq 0x16fa0
cmpl $-0x1, %eax
je 0x17167
cltq
shlq $0x7, %rax
leaq 0x215865(%rip), %rcx    # 0x22c990
leaq (%rcx,%rax), %rdi
cmpb $0x0, (%rax,%rcx)
jne 0x17141
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x4f58(%rip), %rsi      # 0x1c0a0
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
movsd 0x8(%rsp), %xmm0
jne 0x1716d
movsd 0x10(%rsp), %xmm0
jmp 0x1716d
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsi, 0x8(%rsp)
xorl %esi, %esi
callq 0x16fa0
cmpl $-0x1, %eax
je 0x171be
cltq
shlq $0x7, %rax
leaq 0x2157f8(%rip), %rdi    # 0x22c990
cmpb $0x0, (%rax,%rdi)
je 0x171be
addq %rax, %rdi
leaq 0x77c8(%rip), %rsi      # 0x1e970
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
jne 0x171be
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x20d771(%rip), %r14    # 0x224990
leaq 0x21576a(%rip), %r15    # 0x22c990
cmpq $0x8000, %rbx           # imm = 0x8000
je 0x17247
leaq (%r14,%rbx), %rdi
callq 0xed98
leaq (%r15,%rbx), %rdi
callq 0xed98
subq $-0x80, %rbx
jmp 0x17226
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x215733(%rip), %rbx    # 0x22c990
leaq 0x20d72c(%rip), %r14    # 0x224990
movl $0x80, %r13d
leaq 0x7703(%rip), %r15      # 0x1e974
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0x172a1
cmpb $0x0, (%r14)
je 0x17296
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8180
incq %r12
addq %r13, %rbx
addq %r13, %r14
jmp 0x17274
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/schroeder-lvb[P]sissm/src/p2p.c
// Function: p2pTestMain
int p2pTestMain()
{
    p2pInit();

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

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

    p2pDebugDump();

    return 0;
}

// Assembly:
pushq %rbx
callq 0x17211
leaq 0x76ca(%rip), %rbx      # 0x1e982
leaq 0x76cb(%rip), %rsi      # 0x1e98a
movq %rbx, %rdi
callq 0x170aa
leaq 0x76c4(%rip), %rsi      # 0x1e992
movq %rbx, %rdi
callq 0x170aa
leaq 0x76bd(%rip), %rsi      # 0x1e99a
movq %rbx, %rdi
callq 0x170aa
leaq 0x76b6(%rip), %rsi      # 0x1e9a2
movq %rbx, %rdi
callq 0x170aa
leaq 0x841c(%rip), %rsi      # 0x1f717
movq %rbx, %rdi
callq 0x171c7
leaq 0x76a2(%rip), %rdi      # 0x1e9ac
leaq 0x21d67f(%rip), %rsi    # 0x234990
xorl %eax, %eax
callq 0x8180
leaq 0x7696(%rip), %rbx      # 0x1e9b5
movsd 0x7621(%rip), %xmm0     # 0x1e948
movq %rbx, %rdi
callq 0x16f38
movsd 0x7619(%rip), %xmm0     # 0x1e950
movq %rbx, %rdi
callq 0x16f38
movsd 0x7611(%rip), %xmm0     # 0x1e958
movq %rbx, %rdi
callq 0x16f38
movsd 0x7609(%rip), %xmm0     # 0x1e960
movq %rbx, %rdi
callq 0x16f38
leaq 0x7662(%rip), %rdi      # 0x1e9c8
movsd 0x75fa(%rip), %xmm0     # 0x1e968
callq 0x17102
leaq 0x7644(%rip), %rdi      # 0x1e9be
movb $0x1, %al
callq 0x8180
callq 0x1724d
xorl %eax, %eax
popq %rbx
retq
nop