LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: copy3
static int _copy3( char *dst, char *src, int maxChars )
{
    int validFlag = 0;

    if ((src != NULL) && (dst != NULL)) {
        validFlag = 1;
        if      (0 == strncmp( src, " | ", 3)) strlcpy( dst, &src[3], maxChars );
        else if (0 == strncmp( src, "| ",  2)) strlcpy( dst, &src[2], maxChars );
        else if (0 == strncmp( src, " |",  2)) strlcpy( dst, &src[2], maxChars );
        else                                   strlcpy( dst,  src,    maxChars );  
    }
    return( validFlag );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x19faa
cmpq $0x0, -0x8(%rbp)
je 0x19faa
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcb8c(%rip), %rsi      # 0x26a8e
movl $0x3, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x19f2b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x3, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
jmp 0x19fa8
movq -0x10(%rbp), %rdi
leaq 0xcb59(%rip), %rsi      # 0x26a8f
movl $0x2, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x19f5f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
jmp 0x19fa6
movq -0x10(%rbp), %rdi
leaq 0xcb28(%rip), %rsi      # 0x26a92
movl $0x2, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x19f93
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
jmp 0x19fa4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x11bc0
jmp 0x19fa6
jmp 0x19fa8
jmp 0x19faa
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterCount
int rosterCount( void )
{
    int i, count = 0;
    long devOverride;

    for (i=0; i<ROSTER_MAX; i++) {
        if ( strlen( masterRoster[i].netID ) ) {
            if (( rosterIsValidGUID(  masterRoster[i].steamID)) && ( 0 != strlen( masterRoster[i].IPaddress )) )  { 
                count++;
            }
        }
    }

    if ( 0L != (devOverride = p2pGetL( "dev.p2p.humans", 0L )) ) {
        count = 0xffL & devOverride;
    }

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x1a06f
movslq -0x4(%rbp), %rax
leaq 0x1f66b2(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
callq 0x8110
cmpq $0x0, %rax
je 0x1a05f
movslq -0x4(%rbp), %rax
leaq 0x1f6692(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xa0, %rdi
callq 0x190a0
cmpl $0x0, %eax
je 0x1a05d
movslq -0x4(%rbp), %rax
leaq 0x1f666c(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xf0, %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1a05d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1a05f
jmp 0x1a061
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x19fd6
leaq 0xa6f6(%rip), %rdi      # 0x2476c
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1a09a
movq -0x10(%rbp), %rax
andq $0xff, %rax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupNameFromIP
char *rosterLookupNameFromIP( char *playerIP )
{
    static char playerName[256];
    int i;
    strclr( playerName );
    for (i=0; i<ROSTER_MAX; i++) {
        if ( 0 == strcmp( masterRoster[i].IPaddress, playerIP )) {
            strlcpy( playerName, masterRoster[i].playerName, 256 ); 
            break;
        }
    }
    return( playerName );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x202ddd(%rip), %rdi    # 0x21cea0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a13e
movslq -0xc(%rbp), %rax
leaq 0x1f65bd(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xf0, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a131
movslq -0xc(%rbp), %rax
leaq 0x1f6590(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0x50, %rsi
leaq 0x202d7b(%rip), %rdi    # 0x21cea0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1a13e
jmp 0x1a133
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a0cf
leaq 0x202d5b(%rip), %rax    # 0x21cea0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterLookupNameFromGUID
char *rosterLookupNameFromGUID( char *playerGUID )
{
    static char playerName[256];
    int i;
    strclr( playerName );
    for (i=0; i<ROSTER_MAX; i++) {
        if ( 0 == strcmp( masterRoster[i].steamID, playerGUID )) {
            strlcpy( playerName, masterRoster[i].playerName, 256 );
            break;
        }
    }
    return( playerName );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x202e3d(%rip), %rdi    # 0x21cfa0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a1de
movslq -0xc(%rbp), %rax
leaq 0x1f651d(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xa0, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a1d1
movslq -0xc(%rbp), %rax
leaq 0x1f64f0(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0x50, %rsi
leaq 0x202ddb(%rip), %rdi    # 0x21cfa0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1a1de
jmp 0x1a1d3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a16f
leaq 0x202dbb(%rip), %rax    # 0x21cfa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x202e9d(%rip), %rdi    # 0x21d0a0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a281
movslq -0xc(%rbp), %rax
leaq 0x1f647d(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0xa0, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a274
movslq -0xc(%rbp), %rax
leaq 0x1f6450(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0xf0, %rsi
leaq 0x202e38(%rip), %rdi    # 0x21d0a0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1a281
jmp 0x1a276
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a20f
leaq 0x202e18(%rip), %rax    # 0x21d0a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x202efd(%rip), %rdi    # 0x21d1a0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a31e
movslq -0xc(%rbp), %rax
leaq 0x1f63dd(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a311
movslq -0xc(%rbp), %rax
leaq 0x1f63b3(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0xa0, %rsi
leaq 0x202e9b(%rip), %rdi    # 0x21d1a0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1a31e
jmp 0x1a313
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a2af
leaq 0x202e7b(%rip), %rax    # 0x21d1a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
cmpl -0xc(%rbp), %eax
jl 0x1a3e7
leaq 0x202f41(%rip), %rdi    # 0x21d2a0
callq 0x122b0
movl $0x0, -0x10(%rbp)
cmpl $0x80, -0x10(%rbp)
jge 0x1a3e5
movslq -0x10(%rbp), %rax
leaq 0x1f6321(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1a3d8
movslq -0x10(%rbp), %rax
leaq 0x1f62f5(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0xa0, %rsi
leaq 0x202edd(%rip), %rdi    # 0x21d2a0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a3e5
jmp 0x1a3da
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a36b
jmp 0x1a3e7
cmpl $0x1, -0x14(%rbp)
je 0x1a3f9
leaq 0x202eac(%rip), %rdi    # 0x21d2a0
callq 0x122b0
leaq 0x202ea0(%rip), %rax    # 0x21d2a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x202f7d(%rip), %rdi    # 0x21d3a0
callq 0x122b0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a49e
movslq -0xc(%rbp), %rax
leaq 0x1f625d(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a491
movslq -0xc(%rbp), %rax
leaq 0x1f6233(%rip), %rsi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rsi
addq $0xf0, %rsi
leaq 0x202f1b(%rip), %rdi    # 0x21d3a0
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
jmp 0x1a49e
jmp 0x1a493
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a42f
leaq 0x202efb(%rip), %rax    # 0x21d3a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1a930
movslq -0xc(%rbp), %rax
leaq 0x1f5e93(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
callq 0x8110
cmpq $0x0, %rax
je 0x1a920
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0xc(%rbp), %rax
leaq 0x1f5e61(%rip), %rdi    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdi
leaq 0x92c0(%rip), %rsi      # 0x23b10
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1a864
movl $0x1, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1a877
cmpl $0x0, -0x10(%rbp)
je 0x1a877
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1a88a
cmpl $0x0, -0x10(%rbp)
jne 0x1a88a
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %esi
movslq -0xc(%rbp), %rax
leaq 0x1f5e08(%rip), %rdx    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rdx
movslq -0xc(%rbp), %rax
leaq 0x1f5df3(%rip), %rcx    # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %rcx
addq $0x50, %rcx
movslq -0xc(%rbp), %rax
leaq 0x1f5dda(%rip), %r8     # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %r8
addq $0xa0, %r8
movslq -0xc(%rbp), %rax
leaq 0x1f5dbe(%rip), %r9     # 0x2106a0
imulq $0x190, %rax, %rax      # imm = 0x190
addq %rax, %r9
addq $0xf0, %r9
movslq -0xc(%rbp), %rdi
leaq 0x1f5da2(%rip), %rax    # 0x2106a0
imulq $0x190, %rdi, %rdi      # imm = 0x190
addq %rdi, %rax
addq $0x140, %rax            # imm = 0x140
leaq 0xbfed(%rip), %rdi      # 0x26902
movq %rax, (%rsp)
movb $0x0, %al
callq 0x8170
jmp 0x1a922
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a7f5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1ff0, %rsp           # imm = 0x1FF0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x1fd0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1f9c, %edx           # imm = 0x1F9C
callq 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x20(%rbp), %rdi
callq 0x122b0
movq -0x28(%rbp), %rdi
callq 0x122b0
leaq -0x1fd0(%rbp), %rdi
leaq 0xbf7e(%rip), %rsi      # 0x2691a
callq 0x8390
movq %rax, -0x1fd8(%rbp)
cmpq $0x0, -0x1fd8(%rbp)
jne 0x1a9cc
leaq -0x1fd0(%rbp), %rdi
leaq 0xbf87(%rip), %rsi      # 0x26947
callq 0x8390
movq %rax, -0x1fd8(%rbp)
cmpq $0x0, -0x1fd8(%rbp)
je 0x1a9e8
movq -0x1fd8(%rbp), %rax
addq $0x2c, %rax
movq %rax, -0x1fd8(%rbp)
cmpq $0x0, -0x1fd8(%rbp)
je 0x1aa68
movq -0x1fd8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %r8d
movl $0x5b, %esi
movl $0x5d, %edx
callq 0x19200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1aa66
movq -0x28(%rbp), %rax
movq %rax, -0x1fe8(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a1f0
movq -0x1fe8(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x18(%rbp), %rax
movq %rax, -0x1fe0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a150
movq -0x1fe0(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
jmp 0x1aa68
addq $0x1ff0, %rsp           # imm = 0x1FF0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9697(%rip), %rdx      # 0x24158
callq 0x122d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x966a(%rip), %rdx      # 0x24158
callq 0x122d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x122b0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1ab64
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x1ab46
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x1ab57
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1ab64
jmp 0x1ab59
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ab13
cmpl $0x0, -0x30(%rbp)
je 0x1ab82
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x30(%rbp), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x8(%rbp), %rcx
movl $0x3, %edi
leaq 0xbde2(%rip), %rsi      # 0x26974
leaq 0xbdea(%rip), %rdx      # 0x26983
movb $0x0, %al
callq 0x21bf0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movl $0x3, %edi
leaq 0xbdbc(%rip), %rsi      # 0x26974
leaq 0xbddb(%rip), %rdx      # 0x2699a
movb $0x0, %al
callq 0x21bf0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x9547(%rip), %rdx      # 0x24158
callq 0x122d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x951a(%rip), %rdx      # 0x24158
callq 0x122d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x122b0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1acb4
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x1ac96
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x1aca7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1acb4
jmp 0x1aca9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ac63
cmpl $0x0, -0x30(%rbp)
je 0x1acd2
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x30(%rbp), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbcb3(%rip), %rsi      # 0x269b9
callq 0x8390
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1ad8d
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a290
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a410
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbc04(%rip), %rsi      # 0x269ca
callq 0x8390
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1ae66
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0xbbed(%rip), %rdx      # 0x269d7
callq 0x122d0
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1ae10
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
jmp 0x1ae24
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rdx
leaq 0x88f2(%rip), %rsi      # 0x23711
callq 0x11bc0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1a0b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a290
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x8(%rbp), %rdi
leaq 0x98f1(%rip), %rsi      # 0x249e8
callq 0x8390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b16d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0xd, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x8110
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0x1b16b
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1b169
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x1b15c
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1b169
jmp 0x1b15e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1b135
jmp 0x1b16b
jmp 0x1b16d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/roster.c
// Function: rosterParseMapname
void rosterParseMapname( char *mapLogString, int maxChars, char *mapName )
{
    char *w;

    strclr( mapName );
    w = strstr( mapLogString, "SeamlessTravel to:" );
    if ( w != NULL ) strlcpy( mapName, &w[19], maxChars );
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x8(%rbp), %rdi
leaq 0x96b9(%rip), %rsi      # 0x24860
callq 0x8390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b1cc
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x428(%rbp)
movq $0x0, -0x430(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movl $0x1, -0x438(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x8110
movl %eax, -0x434(%rbp)
cmpl $0x1, -0x434(%rbp)
jl 0x1b59f
movslq -0x434(%rbp), %rax
movsbl -0x420(%rbp,%rax), %eax
cmpl $0x5b, %eax
jne 0x1b58c
movslq -0x434(%rbp), %rcx
leaq -0x420(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x430(%rbp)
movq -0x430(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x438(%rbp)
jmp 0x1b59f
jmp 0x1b58e
movl -0x434(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x434(%rbp)
jmp 0x1b541
cmpl $0x0, -0x438(%rbp)
jne 0x1b615
movl $0x1, -0x438(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x20(%rbp), %rdi
movq -0x430(%rbp), %rsi
addq $0x1, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x20(%rbp), %rdi
leaq 0x8d2f(%rip), %rsi      # 0x24318
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x428(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1b613
movq -0x428(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x438(%rbp)
jmp 0x1b615
movl -0x438(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushInitCB
int piantirushInitCB( char *strIn )
{
    _captureSpeedForceNext();
    _captureSpeed( 0 );

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

    kickArmed = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1bf80
xorl %edi, %edi
callq 0x1b9c0
callq 0x1bf90
movl $0x0, 0x20bec9(%rip)    # 0x227e40
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x1c04c
movslq -0x4(%rbp), %rax
leaq 0x20bedc(%rip), %rdi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rax
leaq 0x20bec2(%rip), %rdi    # 0x227e90
imulq $0x8c, %rax, %rax
addq %rax, %rdi
addq $0x40, %rdi
callq 0x122b0
movslq -0x4(%rbp), %rcx
leaq 0x20bea4(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x80(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x20be85(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x84(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x20be66(%rip), %rax    # 0x227e90
imulq $0x8c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x88(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1bf9f
movl $0x0, 0x20bdea(%rip)    # 0x227e40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushGameStartCB
int piantirushGameStartCB( char *strIn )
{
    // Disable the no-kick protection window.  "nokickprotect" is a countdown, typically
    // set to numbers like 15L seconds by picladmin !nk (!nokick) command to exempt
    // anticipated antrush auto-kicks for new players in-training, and commander calls over cache.
    //
    p2pSetL( "piantirush.p2p.nokickprotect", 0L );

    // if training mode is "on by default" in sissm1.cfg, for the p2p variable
    // to turn it on a start of each game.  Admins can still turn it off by !wax off.
    // This must be done before _startOfEverything()
    //
    if ( piantirushConfig.trainingOnDefaultEnable ) 
        p2pSetL( "piantirush.p2p.training", 1L );

    _captureSpeedForceNext();
    _startOfEverything();
    kickArmed = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7eb1(%rip), %rdi      # 0x23f74
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
cmpl $0x0, 0x20a031(%rip)    # 0x226104
je 0x1c0e6
leaq 0x7836(%rip), %rdi      # 0x23912
movl $0x1, %esi
callq 0x1ebf0
callq 0x1bf80
callq 0x1b830
movl $0x0, 0x20bd46(%rip)    # 0x227e40
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x77ef(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x1c149
leaq 0x77d2(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
callq 0x1bf80
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x7e, 0x15d61(%rip)    # 0x31ed4
movl $0x0, 0x20bcc3(%rip)    # 0x227e40
callq 0x1bf80
callq 0x1b830
movq 0x20bcba(%rip), %rdi    # 0x227e48
movslq 0x20631f(%rip), %rsi    # 0x2224b4
callq 0x12a40
callq 0x193d0
movq %rax, %rdi
leaq 0xad43(%rip), %rsi      # 0x26eec
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1c1dd
movq 0x20bc91(%rip), %rax    # 0x227e50
movq %rax, -0x10(%rbp)
movq 0x20b756(%rip), %rdi    # 0x227920
callq 0x12aa0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x12a40
jmp 0x1c1e9
movq 0x20bc6c(%rip), %rdi    # 0x227e50
callq 0x12a80
callq 0x1bf90
leaq 0x771d(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1c21d
leaq 0x203691(%rip), %rdi    # 0x21f8a0
addq $0x6064, %rdi           # imm = 0x6064
movb $0x0, %al
callq 0x178d0
movq 0x20bc14(%rip), %rdi    # 0x227e38
callq 0x12a80
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushCapturedCB
int piantirushCapturedCB( char *strIn )
{
    static unsigned long int lastTimeCaptured  = 0L;
    static unsigned long int lastTimeCaptured2 = 0L;

    kickArmed = 0;
    _startOfEverything(); 

    // if in training mode, announce it at Capture & RoundStart
    //
    if ( 0L != p2pGetL( "piantirush.p2p.training", 0L ) ) {

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

    // if geneva restriction is enabled, announce it at Capture & RoundStart
    //
    if ( 0L != p2pGetL( "piantirush.p2p.genevaKick", 0L ) ) {

        // system generates multiple 'captured' report, so it is necessary
        // to add a 10-second window filter to make sure only one gets fired off.
        //
        if ( lastTimeCaptured2 + 10L < apiTimeGet() ) {
            lastTimeCaptured2 = apiTimeGet();
            apiSay( "%s %s", 
                piantirushConfig.genevaKickWarnMessage, 
                piantirushConfig.genevaWeapons );
        }
    }

#if 0
    kickArmed = 0;
    _startOfEverything(); 


    // if in training mode, announce it at Capture & RoundStart
    //
    if ( 0L != p2pGetL( "piantirush.p2p.training", 0L ) )
       apiSay( piantirushConfig.trainingModeMsg );
#endif 

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0x20bbba(%rip)    # 0x227e40
callq 0x1b830
leaq 0x7680(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1c2e8
movq 0x20bbac(%rip), %rax    # 0x227e58
addq $0xa, %rax
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x1c2e6
callq 0x150c0
movq %rax, 0x20bb87(%rip)    # 0x227e58
leaq 0x2035c8(%rip), %rdi    # 0x21f8a0
addq $0x6064, %rdi           # imm = 0x6064
movb $0x0, %al
callq 0x178d0
jmp 0x1c2e8
leaq 0x757e(%rip), %rdi      # 0x2386d
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1c356
movq 0x20bb57(%rip), %rax    # 0x227e60
addq $0xa, %rax
movq %rax, -0x18(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x1c354
callq 0x150c0
movq %rax, 0x20bb32(%rip)    # 0x227e60
leaq 0x9b55(%rip), %rdi      # 0x25e8a
leaq 0x203564(%rip), %rdx    # 0x21f8a0
movq %rdx, %rsi
addq $0x787c, %rsi           # imm = 0x787C
addq $0x747c, %rdx           # imm = 0x747C
movb $0x0, %al
callq 0x178d0
jmp 0x1c356
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1cafb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x187d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x849e(%rip), %rsi      # 0x24fdb
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1cb6b
movq -0x20(%rbp), %rdi
leaq 0x74aa(%rip), %rsi      # 0x23fff
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1cb6b
movl $0x0, -0x4(%rbp)
jmp 0x1cbcd
xorl %eax, %eax
cmpl 0x20b2f5(%rip), %eax    # 0x227e68
jne 0x1cbc7
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq 0x20d5e8(%rip), %rdi    # 0x22a190
movl $0x50, %esi
callq 0x80b0
leaq 0x20d5d7(%rip), %rdi    # 0x22a190
movb $0x0, %al
callq 0x178d0
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rax
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
leaq 0x9efa(%rip), %rsi      # 0x26af2
leaq 0x9fd7(%rip), %rdx      # 0x26bd6
movb $0x0, %al
callq 0x21bf0
callq 0x1bf80
xorl %edi, %edi
callq 0x1b9c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x20b215(%rip), %rdi    # 0x227e48
movslq 0x20587a(%rip), %rsi    # 0x2224b4
callq 0x12a40
callq 0x1bf90
callq 0x193d0
movq %rax, %rdi
leaq 0xa299(%rip), %rsi      # 0x26eec
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x1cc87
movq 0x20b1e7(%rip), %rax    # 0x227e50
movq %rax, -0x10(%rbp)
movq 0x20acac(%rip), %rdi    # 0x227920
callq 0x12aa0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x12a40
jmp 0x1cc93
movq 0x20b1c2(%rip), %rdi    # 0x227e50
callq 0x12a80
movl $0xffffffff, 0x15243(%rip) # imm = 0xFFFFFFFF
movl $0x2, 0x1523d(%rip)     # 0x31ee4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
leaq -0x210(%rbp), %rcx
leaq -0x310(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0x1a940
cmpl $0x0, 0x2057cf(%rip)    # 0x2224b8
je 0x1cd94
cmpl $0x0, 0x20b176(%rip)    # 0x227e6c
jne 0x1cd92
movq 0x20ac1d(%rip), %rdi    # 0x227920
callq 0x12aa0
movslq 0x206bb1(%rip), %rcx    # 0x2238c0
cmpq %rcx, %rax
jl 0x1cd92
cmpl $0x0, 0x151c9(%rip)     # 0x31ee4
je 0x1cd90
cmpl $0x0, 0x20b11c(%rip)    # 0x227e40
je 0x1cd90
leaq -0x110(%rbp), %rsi
leaq -0x210(%rbp), %rdx
xorl %edi, %edi
leaq 0x202b63(%rip), %rcx    # 0x21f8a0
addq $0x3820, %rcx           # imm = 0x3820
callq 0x1cdf0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1cd8e
leaq -0x110(%rbp), %rcx
leaq -0x210(%rbp), %r8
movl $0x1, %edi
leaq 0x9d87(%rip), %rsi      # 0x26af2
leaq 0x9e92(%rip), %rdx      # 0x26c04
movb $0x0, %al
callq 0x21bf0
leaq -0x110(%rbp), %rsi
leaq 0x9eac(%rip), %rdi      # 0x26c33
movb $0x0, %al
callq 0x1cac0
jmp 0x1cd90
jmp 0x1cd92
jmp 0x1cd94
movl $0x0, 0x20b0a2(%rip)    # 0x227e40
movslq 0x209367(%rip), %rax    # 0x22610c
cmpq $0x0, %rax
je 0x1cdde
movq 0x20b086(%rip), %rdi    # 0x227e38
movslq 0x209353(%rip), %rsi    # 0x22610c
callq 0x12a40
movl 0x209348(%rip), %ecx    # 0x22610c
movl $0x2, %edi
leaq 0x9d22(%rip), %rsi      # 0x26af2
leaq 0x9e79(%rip), %rdx      # 0x26c50
movb $0x0, %al
callq 0x21bf0
xorl %eax, %eax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopl (%rax)