LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdRcon
int _cmdRcon( char *arg, char *arg2, char *passThru ) 
{ 
    int bytesRead, errCode = 1;
    char statusIn[4096];
    char *rconArgs;
    int  supportedRconCommand = 1;
    char *unsupportedRcon[] =  { "help", "listplayers", "listbans", "maps", "scenarios", "listgamemodeproperties", "*" };

    supportedRconCommand = !foundMatch( arg, unsupportedRcon, 1 );

    if ( supportedRconCommand ) {
        rconArgs = strstr( passThru, " " );
        if ( rconArgs != NULL ) {  
            bytesRead = apiRcon( rconArgs, statusIn );
            if ( bytesRead != 0 )  {
                errCode = 0;
                apiSaySys( statusIn );
            }
            else {
                apiSaySys( "RCON Interface Error" );
            }
        }
    }
    else {
        apiSaySys( "Unsupported RCON command" );
    }
    return errCode;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1048, %rsp           # imm = 0x1048
movq %rdx, %r14
movq 0x1cdb6(%rip), %rax     # 0x27de0
movq %rsp, %rsi
movq %rax, 0x30(%rsi)
movaps 0x1cd98(%rip), %xmm0    # 0x27dd0
movaps %xmm0, 0x20(%rsi)
movaps 0x1cd7d(%rip), %xmm0    # 0x27dc0
movaps %xmm0, 0x10(%rsi)
movaps 0x1cd62(%rip), %xmm0    # 0x27db0
movaps %xmm0, (%rsi)
movl $0x1, %ebx
movl $0x1, %edx
callq 0xf542
testl %eax, %eax
je 0xb06d
leaq 0x10d54(%rip), %rdi     # 0x1bdbf
jmp 0xb0a1
movq %r14, %rdi
movl $0x20, %esi
callq 0x8170
testq %rax, %rax
je 0xb0b5
leaq 0x40(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x134b0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
leaq 0x10d0d(%rip), %rdi     # 0x1bdaa
cmovneq %r14, %rdi
xorl %eax, %eax
callq 0x1316b
movl %ebx, %eax
addq $0x1048, %rsp           # imm = 0x1048
popq %rbx
popq %r14
retq
movl $0x1, %ebx
jmp 0xb0a8
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdInfo
int _cmdInfo( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    char *s, strOut[256];
    double botDiff;
    int botMin, botMax;

    strclr( strOut );

    // get bot counts and difficulty 
    //
    s = apiGameModePropertyGet( "minimumenemies" ); 
    strlcat( strOut, s, 256 );
    s = apiGameModePropertyGet( "maximumenemies" ); 
    strlcat( strOut, ":", 256 );  strlcat( strOut, s, 256 );
    s = apiGameModePropertyGet( "aidifficulty" ); 
    strlcat( strOut, ":", 256 );  strlcat( strOut, s, 256 );

    if ( 3 == sscanf( strOut, "%d:%d:%lf", &botMin, &botMax, &botDiff )) {
        if ( botMin != botMax ) 
            apiSaySys("AI scaled count %d:%d Difficulty %6.3lf", botMin*2, botMax*2, botDiff*10.0 );
        else
            apiSaySys("AI fixed count %d Difficulty %6.3lf", botMax*2, botDiff*10.0 );
    }
    else {
        apiSaySys( "Retrieval error ::%s::", strOut );
    }
    if (apiBPIsActive()) { 
        apiSaySys( "%d of %d players alive", apiBPPlayerCount(), apiPlayersGetCount());
    }


    return errCode; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf4dd
leaq 0x10967(%rip), %rdi     # 0x1ba43
callq 0x12e75
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %rax, %rsi
callq 0xefc4
leaq 0x1095a(%rip), %rdi     # 0x1ba52
callq 0x12e75
movq %rax, %r14
leaq 0x12d86(%rip), %r15     # 0x1de8d
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r15, %rsi
callq 0xefc4
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefc4
leaq 0x10978(%rip), %rdi     # 0x1baa6
callq 0x12e75
movq %rax, %r14
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r15, %rsi
callq 0xefc4
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefc4
leaq 0x10c7b(%rip), %rsi     # 0x1bdd8
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x82d0
cmpl $0x3, %eax
jne 0xb1a6
movl 0x4(%rsp), %esi
movl (%rsp), %edx
cmpl %edx, %esi
jne 0xb1bb
addl %edx, %edx
movsd 0x8(%rsp), %xmm0
mulsd 0x1054c(%rip), %xmm0    # 0x1b6e0
leaq 0x10c6f(%rip), %rdi     # 0x1be0a
movl %edx, %esi
movb $0x1, %al
callq 0x1316b
jmp 0xb1db
leaq 0x10c81(%rip), %rdi     # 0x1be2e
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1316b
jmp 0xb1db
addl %esi, %esi
addl %edx, %edx
movsd 0x8(%rsp), %xmm0
mulsd 0x10513(%rip), %xmm0    # 0x1b6e0
leaq 0x10c0e(%rip), %rdi     # 0x1bde2
movb $0x1, %al
callq 0x1316b
callq 0x11726
testl %eax, %eax
je 0xb202
callq 0x1172e
movl %eax, %ebx
callq 0x134dc
leaq 0x10c4e(%rip), %rdi     # 0x1be45
movl %ebx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdAllowIn
int _cmdAllowIn( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;

    if ( 0 != strlen( arg ) ) {
        p2pSetS( "picladmin.p2p.allowInPattern", arg );
        p2pSetL( "picladmin.p2p.allowTimeStart", apiTimeGet() );
        apiSaySys("Allow-in '%s' for a brief moment", p2pGetS( "picladmin.p2p.allowInPattern","" ));
    }
    else {
        p2pSetS( "picladmin.p2p.allowInPattern", "" );
        p2pSetL( "picladmin.p2p.allowTimeStart", 0L );
        apiSaySys("Allow-in closed");
    }

    // _stddResp( errCode );   // ok or error message to game
    return errCode; 
}

// Assembly:
pushq %rbx
cmpb $0x0, (%rdi)
je 0xb25f
movq %rdi, %rsi
leaq 0x10c3b(%rip), %rbx     # 0x1be5c
movq %rbx, %rdi
callq 0x17f0b
callq 0x114b2
leaq 0x10c44(%rip), %rdi     # 0x1be79
movq %rax, %rsi
callq 0x17ea8
leaq 0x104cd(%rip), %rsi     # 0x1b711
movq %rbx, %rdi
callq 0x1808c
leaq 0x10c43(%rip), %rdi     # 0x1be96
movq %rax, %rsi
xorl %eax, %eax
callq 0x1316b
jmp 0xb28e
leaq 0x10bf6(%rip), %rdi     # 0x1be5c
leaq 0x104a4(%rip), %rsi     # 0x1b711
callq 0x17f0b
leaq 0x10c00(%rip), %rdi     # 0x1be79
xorl %esi, %esi
callq 0x17ea8
leaq 0x10c30(%rip), %rdi     # 0x1beb7
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdSpam
int _cmdSpam( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;

    if (0 == strcmp( "off", arg )) {
        p2pSetF("api.p2p.sayDisable", 1.0 );
        _stddResp( 0 );   // ok message to game
    }
    else if (0 == strcmp( "on", arg )) {
        p2pSetF("api.p2p.sayDisable", 0.0 );
        _stddResp( 0 );   // ok message to game
    }
    else {
        _stddResp( 1 );   // error message to game
    }
    return errCode;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x104e5(%rip), %rdi     # 0x1b782
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0xb2c5
leaq 0x13ca0(%rip), %rdi     # 0x1ef50
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0xb2cf
leaq 0x2aa81(%rip), %rbx     # 0x35d44
jmp 0xb2e5
movsd 0xfd5b(%rip), %xmm0     # 0x1b028
jmp 0xb2d2
xorps %xmm0, %xmm0
leaq 0x10bee(%rip), %rdi     # 0x1bec7
callq 0x17d80
leaq 0x2965f(%rip), %rbx     # 0x34944
callq 0x83c0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movslq %eax, %rdi
shlq $0xa, %rdi
addq %rbx, %rdi
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdPrep
int _cmdPrep( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    char *typeObj, outStr[256];

    typeObj = rosterGetObjectiveType();
    strclr( outStr );
    if ( NULL != strcasestr( typeObj, "weaponcache" ) )
        strlcpy( outStr, picladminConfig.prepBlow, 256 );
    if ( NULL != strcasestr( typeObj, "capturable"  ) )
        strlcpy( outStr, picladminConfig.prepCapture, 256 );

    apiSaySys( outStr );
    return errCode;
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
callq 0x14246
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf4dd
leaq 0x10ba1(%rip), %rsi     # 0x1beda
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0xb35a
leaq 0x4d603(%rip), %rsi     # 0x58950
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
leaq 0x10b85(%rip), %rsi     # 0x1bee6
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0xb382
leaq 0x4d9db(%rip), %rsi     # 0x58d50
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
movq %rsp, %rdi
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdAsk
int _cmdAsk( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    char *typeObj, outStr[256];

    typeObj = rosterGetObjectiveType();
    strclr( outStr );
    if ( NULL != strcasestr( typeObj, "weaponcache" ) ) 
        strlcpy( outStr, picladminConfig.askBlow, 256 );
    if ( NULL != strcasestr( typeObj, "capturable"  ) ) 
        strlcpy( outStr, picladminConfig.askCapture, 256 );

    apiSaySys( outStr );
    return errCode;
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
callq 0x14246
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf4dd
leaq 0x10b24(%rip), %rsi     # 0x1beda
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0xb3d7
leaq 0x4dd86(%rip), %rsi     # 0x59150
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
leaq 0x10b08(%rip), %rsi     # 0x1bee6
movq %rbx, %rdi
callq 0x8350
testq %rax, %rax
je 0xb3ff
leaq 0x4e15e(%rip), %rsi     # 0x59550
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0xf038
movq %rsp, %rdi
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdFast
int _cmdFast( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;

    if (0 == strcmp( "off", arg )) {
        p2pSetF("piantirush.p2p.fast", 0.0 );
        apiSaySys("Anti-Rushing algorithm will be enabled after the next objective");
    }
    else if (0 == strcmp( "on", arg )) {
        p2pSetF("piantirush.p2p.fast", 1.0 );
        apiSaySys("Anti-Rushing algorithm is disabled by admin");
        p2pSetL( "piantirush.p2p.training", 0L );    // turn off WAX
    }
    else {
        if (0.0 == p2pGetF( "piantirush.p2p.fast", 0.0 ) )
            apiSaySys( "Fast is OFF" );
        else
            apiSaySys( "Fast is ON" );
    }

    return errCode;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x102e5(%rip), %rdi     # 0x1b782
movq %rbx, %rsi
callq 0x8220
testl %eax, %eax
je 0xb4e1
leaq 0x13aa0(%rip), %rdi     # 0x1ef50
movq %rbx, %rsi
callq 0x8220
leaq 0x104ae(%rip), %rdi     # 0x1b96d
testl %eax, %eax
je 0xb4fa
xorpd %xmm0, %xmm0
callq 0x17f65
ucomisd 0x10214(%rip), %xmm0    # 0x1b6e8
jne 0xb525
jp 0xb525
leaq 0x10a7e(%rip), %rdi     # 0x1bf5d
jmp 0xb52c
leaq 0x10485(%rip), %rdi     # 0x1b96d
xorpd %xmm0, %xmm0
callq 0x17d80
leaq 0x109f9(%rip), %rdi     # 0x1bef1
jmp 0xb52c
movsd 0xfb26(%rip), %xmm0     # 0x1b028
callq 0x17d80
leaq 0x10a23(%rip), %rdi     # 0x1bf31
xorl %eax, %eax
callq 0x1316b
leaq 0x103f6(%rip), %rdi     # 0x1b912
xorl %esi, %esi
callq 0x17ea8
jmp 0xb533
leaq 0x10a3d(%rip), %rdi     # 0x1bf69
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdNoKick
int _cmdNoKick( char *arg, char *arg2, char *passThru ) 
{ 
    // Run this discretely - so no prompt.
    //
    p2pSetL( "piantirush.p2p.nokickprotect", (long) picladminConfig.noKickProtectSec );
    _stddResp( 0 );

    return 0;
}

// Assembly:
pushq %rbx
leaq 0x29401(%rip), %rbx     # 0x34940
movslq 0x52412(%rip), %rsi     # 0x5d958
leaq 0x10a27(%rip), %rdi     # 0x1bf74
callq 0x17ea8
callq 0x83c0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cltq
shlq $0xa, %rax
leaq (%rax,%rbx), %rdi
addq $0x4, %rdi
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdNoWait
int _cmdNoWait( char *arg, char *arg2, char *passThru ) 
{ 
    // Run this discretely - so no prompt.
    // Set semaphore (binary), will be picked up by Periodic Processing
    // in piantirush plugin
    //
    p2pSetL( "piantirush.p2p.SigNoWait", 1L );
    _stddResp( 0 );

    return 0;
}

// Assembly:
pushq %rax
leaq 0x109fe(%rip), %rdi     # 0x1bf91
movl $0x1, %esi
callq 0x17ea8
callq 0x83c0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cltq
shlq $0xa, %rax
leaq 0x29376(%rip), %rcx     # 0x34940
leaq (%rax,%rcx), %rdi
addq $0x4, %rdi
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdMapList
int _cmdMapList( char *arg, char *arg2, char *passThru ) 
{ 
    char *w, listBuf[1024];
    int errCode = 0;

    if (NULL != (w = apiMapList() )) {
        strlcpy( listBuf, w, 1024 );
        _showList( listBuf );
    }

    return errCode;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
callq 0x13ae1
testq %rax, %rax
je 0xba46
movq %rsp, %rbx
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0xba51
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: showList
static int _showList( char *list )
{
    char *w, *v, outBuf[256];
    int errCode = 1;
    int j, i, exitF = 0;;

    w = list;
    j = 0;
    if ( w != NULL ) { 
        errCode = 0;
        while ( 0 == exitF ) {
            strclr( outBuf );
            for (i=0; i<4; i++) {
                v = getWord( w, j++, " " );
                if ( NULL == v ) {
                    exitF = 1;
                    break;
                }
                if ( 0==strlen( v ) ) {
                    exitF = 1;
                    break;
                }
                strncat( outBuf, v, 255 );
                strncat( outBuf, " ", 255 );
            }
            apiSaySys( "%s", outBuf );
        }
    } 
    return errCode;
}

// Assembly:
testq %rdi, %rdi
je 0xbaff
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq %rsp, %r14
leaq 0x106de(%rip), %r15     # 0x1c156
leaq 0x13205(%rip), %r12     # 0x1ec84
xorl %r13d, %r13d
movq %r14, %rdi
callq 0xf4dd
xorl %ebp, %ebp
leal (%r13,%rbp), %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xf4e1
testq %rax, %rax
je 0xbadd
cmpb $0x0, (%rax)
je 0xbadd
movl $0xff, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x81c0
movq %r14, %rdi
callq 0x8120
movw $0x20, (%rsp,%rax)
incl %ebp
cmpl $0x4, %ebp
jne 0xba8c
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1316b
addl %ebp, %r13d
jmp 0xba82
leaq 0x131a0(%rip), %rdi     # 0x1ec84
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1316b
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdMutList
int _cmdMutList( char *arg, char *arg2, char *passThru )
{
    char *w, listBuf[1024];
    int errCode = 0;

    if (NULL != (w = apiMutList() )) {
        strlcpy( listBuf, w, 1024 );
        _showList( listBuf );
    }

    return errCode;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
callq 0x13d26
testq %rax, %rax
je 0xbb2d
movq %rsp, %rbx
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0xba51
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdMutActive
int _cmdMutActive( char *arg, char *arg2, char *passThru )
{
    char *w, listBuf[1024];
    int errCode = 0;

    if (NULL != (w = apiMutActive( 1 ) )) {
        strlcpy( listBuf, w, 1024 );
        _showList( listBuf );
    }

    return errCode;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl $0x1, %edi
callq 0x13e47
testq %rax, %rax
je 0xbb6a
movq %rsp, %rbx
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0xba51
xorl %eax, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdReInit
int _cmdReInit( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    apiInitAuth();
    apiInitBadWords();

    apiSaySys( "SISSM ReInit Complete." );
    return errCode;
}

// Assembly:
pushq %rax
callq 0x11cff
callq 0x12053
leaq 0x10569(%rip), %rdi     # 0x1c0f0
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdBotRespawn
int _cmdBotRespawn( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    int resetType = 0;

    if ( 1 != sscanf( arg, "%d", &resetType ) ) {
        resetType = 0;
    }
    errCode = apiBotRespawn( resetType );

    apiSaySys( "Bots Respawned" );
    return errCode;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10524(%rip), %rsi     # 0x1c0cd
xorl %eax, %eax
callq 0x82d0
cmpl $0x1, %eax
je 0xbbbd
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x134e6
movl %eax, %ebx
leaq 0x10538(%rip), %rdi     # 0x1c107
xorl %eax, %eax
callq 0x1316b
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdBotReset
int _cmdBotReset( char *arg, char *arg2, char *passThru ) 
{ 
    // signal pidynbots that picladmin (admins) reliquishes 
    // bot count and difficulty overrides.
    //
    p2pSetL( "picladmin.p2p.botAdminControlDifficulty", 0L );
    p2pSetL( "picladmin.p2p.botAdminControl", 0L );

    // signal pidynbots to force refresh bot configurations
    // if pidynbots plugin is not enabled, then ignore.
    //
    p2pSetL( "pidynbots.p2p.sigBotScaled", 1L );

    apiSaySys( "Bot Reset" );
    return 0;
}

// Assembly:
pushq %rax
leaq 0xfecd(%rip), %rdi      # 0x1bab3
xorl %esi, %esi
callq 0x17ea8
leaq 0xfe79(%rip), %rdi      # 0x1ba6d
xorl %esi, %esi
callq 0x17ea8
leaq 0xfe89(%rip), %rdi      # 0x1ba8b
movl $0x1, %esi
callq 0x17ea8
leaq 0x10503(%rip), %rdi     # 0x1c116
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: picladminRoundEndCB
int picladminRoundEndCB( char *strIn )  
{
    if ( _queueReboot == REBOOT_EOR ) {
        _queueReboot = REBOOT_CANCEL;
        apiSaySys( "*Server is REBOOTING - please reconnect" );
        apiServerRestart( "Server Admin Reboot" );
    }
    return 0; 
}

// Assembly:
cmpl $0x1, 0x51897(%rip)     # 0x5dd5c
jne 0xc4f0
pushq %rax
movl $0x0, 0x5188a(%rip)     # 0x5dd5c
leaq 0xf679(%rip), %rdi      # 0x1bb52
xorl %eax, %eax
callq 0x1316b
leaq 0xf693(%rip), %rdi      # 0x1bb7a
callq 0x12ce5
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: picladminGameEndCB
int picladminGameEndCB( char *strIn )  
{
    _resetP2PVars(); 
    if ( _queueReboot == REBOOT_EOG ) {
        _queueReboot = REBOOT_CANCEL;
        apiSaySys( "*Server is REBOOTING - please reconnect" );
        apiServerRestart( "Server Admin Reboot" );
    }
    return 0; 
}

// Assembly:
pushq %rax
callq 0xc52a
cmpl $0x2, 0x5185c(%rip)     # 0x5dd5c
jne 0xc526
movl $0x0, 0x51850(%rip)     # 0x5dd5c
leaq 0xf63f(%rip), %rdi      # 0x1bb52
xorl %eax, %eax
callq 0x1316b
leaq 0xf659(%rip), %rdi      # 0x1bb7a
callq 0x12ce5
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: picladminPeriodicCB
int picladminPeriodicCB( char *strIn ) 
{ 
    if (( _rulesIndex != -1 ) && ( picladminConfig.rulesIntervalSec != 0) ) {
        if ( (++_rulesTickCount) >= picladminConfig.rulesIntervalSec ) {
            _rulesTickCount = 0;
            apiSaySys( picladminConfig.rulesInfo[ _rulesIndex++ ]);
            if ( _rulesIndex >= NUM_RULES ) _rulesIndex = -1;
        }
    }

    // Special condition when EOG/EOR reboot is queued but everybody logs off
    // before end of game/round.
    //
    if (( _queueReboot == REBOOT_EOG ) || ( _queueReboot == REBOOT_EOR )) {
       if ( 0 == apiPlayersGetCount() ) {
           _queueReboot = REBOOT_CANCEL;
           apiSaySys( "*Server is REBOOTING - please reconnect" );
           apiServerRestart( "Server Admin Reboot" );
       }
    }

    return 0; 
}

// Assembly:
pushq %rax
movslq 0x1d138(%rip), %rax     # 0x296b0
cmpq $-0x1, %rax
setne %dl
movl 0x513cb(%rip), %ecx     # 0x5d950
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xc5e9
movl 0x517c6(%rip), %edx     # 0x5dd60
incl %edx
movl %edx, 0x517be(%rip)     # 0x5dd60
cmpl %ecx, %edx
jl 0xc5e9
movl $0x0, 0x517b0(%rip)     # 0x5dd60
leal 0x1(%rax), %ecx
movl %ecx, 0x1d0f7(%rip)     # 0x296b0
shlq $0xa, %rax
leaq 0x2837c(%rip), %rcx     # 0x34940
leaq (%rax,%rcx), %rdi
addq $0x27c10, %rdi          # imm = 0x27C10
xorl %eax, %eax
callq 0x1316b
cmpl $0x5, 0x1d0d3(%rip)     # 0x296b0
jl 0xc5e9
movl $0xffffffff, 0x1d0c7(%rip) # imm = 0xFFFFFFFF
movl 0x5176d(%rip), %eax     # 0x5dd5c
decl %eax
cmpl $0x1, %eax
ja 0xc623
callq 0x134dc
testl %eax, %eax
jne 0xc623
movl $0x0, 0x51753(%rip)     # 0x5dd5c
leaq 0xf542(%rip), %rdi      # 0x1bb52
xorl %eax, %eax
callq 0x1316b
leaq 0xf55c(%rip), %rdi      # 0x1bb7a
callq 0x12ce5
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: commandParse
int _commandParse( char *strIn, int maxStringSize, char *clientGUID, char *cmdString  ) {
    char *w, *v;
    int guidType, parseError = 1;
    char prefixMatch[256];

    strclr( clientGUID );
    strclr( cmdString );

    // Look for start of chat text content 
    //
    strlcpy( prefixMatch, " Chat: ", 256 );       // build search pattern for start of msg
    strlcat( prefixMatch, picladminConfig.cmdPrefix, 256 );         // with command prefix
    w = strstr( strIn, prefixMatch );

    if ( w != NULL ) {
        if (0 != ( guidType = rosterFindFirstID( strIn, '(', ')', clientGUID, maxStringSize ))) {
            v = w + strlen( prefixMatch );
            strlcpy ( cmdString, v, maxStringSize );
            strTrimInPlace( cmdString );
            if (0 != strlen( cmdString )) parseError = 0;
        }
    }
    return parseError;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
callq 0xf4dd
movq %rbx, %rdi
callq 0xf4dd
movabsq $0x203a7461684320, %rax # imm = 0x203A7461684320
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x2bc2d(%rip), %rsi     # 0x38544
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
callq 0xefc4
movq %r15, %rdi
movq %r12, %rsi
callq 0x83b0
movl $0x1, %r13d
testq %rax, %rax
je 0xc984
movq %rax, %r12
movq %r15, %rdi
movl $0x28, %esi
movl $0x29, %edx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x140e0
testl %eax, %eax
je 0xc984
movq %rsp, %rdi
callq 0x8120
addq %rax, %r12
movslq %ebp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0xf5e3
xorl %r13d, %r13d
cmpb $0x0, (%rbx)
sete %r13b
movl %r13d, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: commandParseFromRCON
int _commandParseFromRCON( char *strIn, int maxStringSize, char *clientGUID, char *cmdString  )
{
    int parseError = 1;
    char *u, *v, *w;

    strclr( clientGUID );
    strclr( cmdString );

    w = strstr( strIn, "<< " );
    if ( w != NULL ) {
        v = w + 3;
        if ( v[0] != 0 ) {
            if ( NULL != (u = strstr( v, picladminConfig.cmdPrefix ))) {
                if ( u == v ) {       // cmdPrefix is the first character of say string...
                    strlcpy( cmdString, u+strlen( picladminConfig.cmdPrefix ), maxStringSize );
                    strTrimInPlace( cmdString );
                    strlcpy( clientGUID, "00000000000000000", 1+RCONSTEAMIDSIZE );   // "root" ID
                    parseError = 0;
                    logPrintf( LOG_LEVEL_INFO, "picladmin", "RCON initiated command ::%s::[%s]::", strIn, cmdString );
                }
            }
        }
    }

    return parseError;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0xf4dd
movq %rbx, %rdi
callq 0xf4dd
leaq 0xfd20(%rip), %rsi      # 0x1c6e6
movq %r14, %rdi
callq 0x83b0
movl $0x1, %r12d
testq %rax, %rax
je 0xca61
movq %rax, %r13
cmpb $0x0, 0x3(%rax)
je 0xca61
movl %ebp, 0x4(%rsp)
addq $0x3, %r13
leaq 0x2bb4f(%rip), %rsi     # 0x38544
movq %r13, %rdi
callq 0x83b0
cmpq %r13, %rax
jne 0xca61
movq %rax, %rbp
leaq 0x2bb38(%rip), %rdi     # 0x38544
callq 0x8120
addq %rax, %rbp
movslq 0x4(%rsp), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0xf5e3
movups 0xfcb7(%rip), %xmm0     # 0x1c6ea
movups %xmm0, (%r15)
movw $0x30, 0x10(%r15)
leaq 0xf242(%rip), %rsi      # 0x1bc87
leaq 0xfcb0(%rip), %rdx      # 0x1c6fc
xorl %r12d, %r12d
movl $0x2, %edi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1a227
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/picladmin.c
// Function: picladminChatCB
int picladminChatCB( char *strIn )
{
    char clientGUID[1024], cmdString[1024];

    if ( 0 == _commandParse( strIn, 1024, clientGUID, cmdString )) {    // parse for valid format
        logPrintf( LOG_LEVEL_DEBUG, "picladmin-chatCB", "strin  ::%s::\n", strIn );
        logPrintf( LOG_LEVEL_DEBUG, "picladmin-chatCB", "parsed ::%s::%s::\n", clientGUID, cmdString );
        _commandExecute( cmdString, clientGUID ) ;                     // execute the command
    }

#if 0
    // pre-auth method using simple apiIsAdmin call - deprecated but left here for short term
    // just in case a revert is needed for test purposes.
    //
    if ( 0 == _commandParse( strIn, 1024, clientGUID, cmdString )) {    // parse for valid format
        if (apiIsAdmin( clientGUID )) {                                    // check if authorized
            _commandExecute( cmdString, clientGUID ) ;                     // execute the command
        }
        else  {
            _respSay( picladminConfig.msgInvalid );                       // unauthorized message
        }
    }
#endif

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %rbx
leaq 0x400(%rsp), %rdx
movq %rsp, %rcx
movl $0x400, %esi            # imm = 0x400
callq 0xc8d3
testl %eax, %eax
jne 0xcaed
leaq 0xfc7e(%rip), %r14      # 0x1c720
leaq 0xfc88(%rip), %rdx      # 0x1c731
movl $0x3, %edi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a227
leaq 0xfc7e(%rip), %rdx      # 0x1c740
leaq 0x400(%rsp), %rbx
movq %rsp, %r15
movl $0x3, %edi
movq %r14, %rsi
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1a227
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc653
xorl %eax, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pitacnomic.c
// Function: pitacnomicInitConfig
int pitacnomicInitConfig( void )
{
    cfsPtr cP;
    int i;
    char varArray[CFS_FETCH_MAX];

    cP = cfsCreate( sissmGetConfigPath() );

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

    // Read the operator-specified "macro" (alias) sequence
    //
    for ( i=0; i<PITACNOMIC_MAXSHORTS; i++ ) {
        snprintf( varArray, 256, "pitacnomic.shorts[%d]", i );
        strlcpy( pitacnomicConfig.shorts[i],     cfsFetchStr( cP, varArray,  "" ),   CFS_FETCH_MAX);
        replaceDoubleColonWithBell( pitacnomicConfig.shorts[i] );
    }

    // Read the list string of two-letter-codes that only 'live' players can issue
    //
    strlcpy( pitacnomicConfig.livePlayersOnly, cfsFetchStr( cP, "pitacnomic.livePlayersOnly",  "" ),   CFS_FETCH_MAX);

    cfsDestroy( cP );
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
callq 0x8969
movq %rax, %rdi
callq 0x9004
movq %rax, %rbx
leaq 0xfaf0(%rip), %rsi      # 0x1c7a4
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x513a6(%rip)     # 0x5e070
leaq 0x513a3(%rip), %r14     # 0x5e074
leaq 0xfae3(%rip), %r15      # 0x1c7bb
movq %rsp, %r12
leaq 0xea2f(%rip), %r13      # 0x1b711
xorl %ebp, %ebp
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x8190
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x907b
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rax, %rsi
callq 0xf038
movq %r14, %rdi
callq 0xf7fe
incq %rbp
addq $0x400, %r14            # imm = 0x400
cmpq $0x64, %rbp
jne 0xcce4
leaq 0xfa9c(%rip), %rsi      # 0x1c7d1
leaq 0xe9d5(%rip), %rdx      # 0x1b711
movq %rbx, %rdi
callq 0x907b
leaq 0x6a329(%rip), %rdi     # 0x77074
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0x905c
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/events.c
// Function: eventsRegister
int eventsRegister( int eventID, int (*callBack)( char * ))
{
    int i, j, callBackIndex = -1, errCode = 1;

    // Translate the eventID to callBackTable index
    // 
    for ( i=0; i<SISSM_MAXEVENTS; i++ ) {
        if ( 0 == strcmp( eventTable[ i ].eventString, "*" ))  {
            break;
        }
        if ( eventTable[ i ].eventID == eventID ) {
            callBackIndex = eventTable[ i ].callBacktableIndex;
            break;          
        }
    }

    // Insert callback function pointer to the first non-null slot
    // in the 'eventsCallbackFunctions' table
    //
    if ( callBackIndex != -1 ) {
        for ( j=0; j<SISSM_MAXPLUGINS ; j++ ) {
            if ( eventsCallbackFunctions[callBackIndex][j] == NULL) {
                eventsCallbackFunctions[callBackIndex][j] = callBack;
                errCode = 0;
                break;
            }
        }
    }
    return errCode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
leaq 0x1c61d(%rip), %r12     # 0x296c0
leaq 0xeb52(%rip), %r14      # 0x1bbfc
movq 0x8(%r15,%r12), %rdi
movq %r14, %rsi
callq 0x8220
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0xd0da
cmpl %ebp, (%r15,%r12)
je 0xd0d5
addq $0x10, %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0xd0aa
jmp 0xd0da
movl 0x4(%r15,%r12), %ecx
movl $0x1, %eax
cmpl $-0x1, %ecx
je 0xd113
movslq %ecx, %rcx
shlq $0x9, %rcx
xorl %edx, %edx
leaq 0x6a38c(%rip), %rsi     # 0x77480
leaq (%rcx,%rdx,8), %rdi
cmpq $0x0, (%rsi,%rdi)
je 0xd10a
incq %rdx
cmpq $0x20, %rdx
jne 0xd0f4
jmp 0xd113
addq %rcx, %rsi
movq %rbx, (%rsi,%rdx,8)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/events.c
// Function: eventsUnRegister
int eventsUnRegister( int eventID, int (*callBack)( char * ))
{
    int i, j, callBackIndex = -1, errCode = 1;

    // Translate the eventID to callBackTable index
    // 
    for ( i=0; i<SISSM_MAXEVENTS; i++ ) {
        if ( 0 == strcmp( eventTable[ i ].eventString, "*" ))  {
            break;
        }
        if ( eventTable[ i ].eventID == eventID ) {
            callBackIndex = eventTable[ i ].callBacktableIndex;
            break;          
        }
    }

    // Remove active callBack vecotors from the events callback table. 
    // While this should not occur, this loop remove duplicate registration, 
    // if any, as a code safety. 
    //
    if ( callBackIndex != -1 ) {
        for ( j=0; j<SISSM_MAXPLUGINS ; j++ ) {
            if ( eventsCallbackFunctions[callBackIndex][j] == callBack) {
                eventsCallbackFunctions[callBackIndex][j] = NULL;
                errCode = 0;
            }
        }
    }

    return errCode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
leaq 0x1c58d(%rip), %r12     # 0x296c0
leaq 0xeac2(%rip), %r14      # 0x1bbfc
movq 0x8(%r15,%r12), %rdi
movq %r14, %rsi
callq 0x8220
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0xd16a
cmpl %ebp, (%r15,%r12)
je 0xd165
addq $0x10, %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0xd13a
jmp 0xd16a
movl 0x4(%r15,%r12), %ecx
cmpl $-0x1, %ecx
je 0xd1ae
movslq %ecx, %rcx
shlq $0x9, %rcx
movl $0x1, %eax
xorl %edx, %edx
leaq 0x6a2fc(%rip), %rsi     # 0x77480
leaq (%rcx,%rdx,8), %rdi
cmpq %rbx, (%rsi,%rdi)
jne 0xd1a3
leaq (,%rdx,8), %rax
addq %rcx, %rax
movq $0x0, (%rsi,%rax)
xorl %eax, %eax
incq %rdx
cmpq $0x20, %rdx
jne 0xd184
jmp 0xd1b3
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/events.c
// Function: eventsDispatch
int eventsDispatch( char *strBuffer )
{
    int i, j;
    int activeCallBackIndex = -1;

    for (i=0; i<SISSM_MAXEVENTS; i++) { 
     
        if ( 0 == strlen( eventTable[i].eventString )) 
            continue; 
        if ( 0 == strcmp( eventTable[i].eventString, "*" )) 
            break;

        if ( NULL != strstr( strBuffer, eventTable[i].eventString ) ) {
            activeCallBackIndex = eventTable[i].callBacktableIndex;
            if ( activeCallBackIndex >= 0 ) {
                for (j=0; j<SISSM_MAXPLUGINS; j++) {
                    if ( NULL != eventsCallbackFunctions[activeCallBackIndex][j] ) {
                         (*eventsCallbackFunctions[activeCallBackIndex][j])( strBuffer );
                    }
                }
            }
            break;
        }
        if (0==strcmp( "*", eventTable[i].eventString )) break;
    }
    return activeCallBackIndex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x1c4f5(%rip), %r13     # 0x296c8
leaq 0xea22(%rip), %r15      # 0x1bbfc
movq (%r13), %r12
cmpb $0x0, (%r12)
je 0xd220
movq %r12, %rdi
movq %r15, %rsi
callq 0x8220
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0xd26b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x83b0
testq %rax, %rax
jne 0xd22d
movq %r15, %rdi
movq %r12, %rsi
callq 0x8220
testl %eax, %eax
je 0xd26b
cmpl $0x3f, %ebp
jb 0xd225
jmp 0xd26b
cmpl $0x3e, %ebp
ja 0xd265
incl %ebp
addq $0x10, %r13
jmp 0xd1da
movslq -0x4(%r13), %r14
testq %r14, %r14
js 0xd26b
movq %r14, %r15
shlq $0x9, %r15
xorl %r12d, %r12d
leaq 0x6a239(%rip), %r13     # 0x77480
leaq (%r15,%r12,8), %rax
movq (%r13,%rax), %rax
testq %rax, %rax
je 0xd25a
movq %rbx, %rdi
callq *%rax
incq %r12
cmpq $0x20, %r12
jne 0xd247
jmp 0xd26b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterInitCB
int pirebooterInitCB( char *strIn )
{
    pirebooterConfig.timeLastReboot = apiTimeGet();
    pirebooterConfig.timeLastProgress = apiTimeGet();
    pirebooterConfig.timeFirstIdle  = 0;

    return 0;
}

// Assembly:
pushq %rax
callq 0x114b2
movq %rax, 0x6e429(%rip)     # 0x7b8b0
callq 0x114b2
movq %rax, 0x6e42d(%rip)     # 0x7b8c0
movq $0x0, 0x6e41a(%rip) # 0x7b8b8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterGameStartCB
int pirebooterGameStartCB( char *strIn )
{
    pirebooterConfig.timeFirstIdle  = 0;
    pirebooterConfig.timeLastProgress = apiTimeGet();

    // Sometimes the server does not appear to generate the End of Game event.
    // This is a duplicate code (see pirebooterGameEndCB) as a 2nd trap
    // to make sure server gets rebooted.
    // 
    if (( pirebooterConfig.timeLastReboot + pirebooterConfig.rebootBusySec ) < apiTimeGet() ) {
        pirebooterConfig.timeLastReboot   = apiTimeGet();
        pirebooterConfig.timeFirstIdle    = 0L;
        pirebooterConfig.timeLastProgress = apiTimeGet();
        logPrintf( LOG_LEVEL_INFO, "pirebooter", "Reboot due to BUSY timer" );
        apiServerRestart( "Uptime Limit Reboot" );     // since the server is empty, reboot right away
    }
    return 0;
}

// Assembly:
pushq %rbx
movq $0x0, 0x6e3eb(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e3e7(%rip)     # 0x7b8c0
movq 0x6dfb0(%rip), %rbx     # 0x7b490
addq 0x6e3c9(%rip), %rbx     # 0x7b8b0
callq 0x114b2
cmpq %rax, %rbx
jae 0xd53a
callq 0x114b2
movq %rax, 0x6e3b3(%rip)     # 0x7b8b0
movq $0x0, 0x6e3b0(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e3ac(%rip)     # 0x7b8c0
leaq 0xf776(%rip), %rsi      # 0x1cc91
leaq 0xf77a(%rip), %rdx      # 0x1cc9c
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
leaq 0xf780(%rip), %rdi      # 0x1ccb5
callq 0x12ce5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterGameEndCB
int pirebooterGameEndCB( char *strIn )
{
    pirebooterConfig.timeFirstIdle  = 0L;
    pirebooterConfig.timeLastProgress = apiTimeGet();

    // Check if the server has been running long, and reboot only at
    // end-of-game to be least intrusive.
    // 
    if (( !pirebooterConfig.rebootOnEOR )) {   // check if reboot is at end of round or end of game
        if (( pirebooterConfig.timeLastReboot + pirebooterConfig.rebootBusySec ) < apiTimeGet() ) {
            pirebooterConfig.timeLastReboot = apiTimeGet();
            pirebooterConfig.timeFirstIdle  = 0L;
            pirebooterConfig.timeLastProgress = apiTimeGet();
            logPrintf( LOG_LEVEL_INFO, "pirebooter", "Reboot due to BUSY timer" );
            apiServerRestart( "Uptime Limit Reboot" );     // since the server is empty, reboot right away
        }
    }

    return 0;
}

// Assembly:
pushq %rbx
movq $0x0, 0x6e36e(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e36a(%rip)     # 0x7b8c0
cmpq $0x0, 0x6e34a(%rip)     # 0x7b8a8
jne 0xd5c1
movq 0x6df29(%rip), %rbx     # 0x7b490
addq 0x6e342(%rip), %rbx     # 0x7b8b0
callq 0x114b2
cmpq %rax, %rbx
jae 0xd5c1
callq 0x114b2
movq %rax, 0x6e32c(%rip)     # 0x7b8b0
movq $0x0, 0x6e329(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e325(%rip)     # 0x7b8c0
leaq 0xf6ef(%rip), %rsi      # 0x1cc91
leaq 0xf6f3(%rip), %rdx      # 0x1cc9c
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
leaq 0xf6f9(%rip), %rdi      # 0x1ccb5
callq 0x12ce5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterRoundStartCB
int pirebooterRoundStartCB( char *strIn )
{
    pirebooterConfig.timeFirstIdle  = 0L;
    pirebooterConfig.timeLastProgress = apiTimeGet();

    if (( pirebooterConfig.timeLastReboot + pirebooterConfig.rebootBusySec ) < apiTimeGet() )
	apiSaySys( pirebooterConfig.rebootWarning );

    return 0;
}

// Assembly:
pushq %rbx
movq $0x0, 0x6e2e7(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e2e3(%rip)     # 0x7b8c0
movq 0x6deac(%rip), %rbx     # 0x7b490
addq 0x6e2c5(%rip), %rbx     # 0x7b8b0
callq 0x114b2
cmpq %rax, %rbx
jae 0xd603
leaq 0x6e2cc(%rip), %rdi     # 0x7b8c8
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterRoundEndCB
int pirebooterRoundEndCB( char *strIn )
{
    pirebooterConfig.timeLastProgress = apiTimeGet();
    pirebooterConfig.timeFirstIdle  = 0L;

    // If the option is enabled to reboot at end-of-round instead of end-of-game,
    // this block of code will execute.
    //
    if (( pirebooterConfig.rebootOnEOR )) {
        if (( pirebooterConfig.timeLastReboot + pirebooterConfig.rebootBusySec ) < apiTimeGet() ) {
            pirebooterConfig.timeLastReboot   = apiTimeGet();
            pirebooterConfig.timeFirstIdle    = 0L;
            pirebooterConfig.timeLastProgress = apiTimeGet();
            logPrintf( LOG_LEVEL_INFO, "pirebooter", "Reboot EOR due to BUSY timer" );
            apiServerRestart( "Uptime Limit Reboot" );     // since the server is empty, reboot right away
        }
    }
    return 0;
}

// Assembly:
pushq %rbx
callq 0x114b2
movq %rax, 0x6e2ac(%rip)     # 0x7b8c0
movq $0x0, 0x6e299(%rip) # 0x7b8b8
cmpq $0x0, 0x6e281(%rip)     # 0x7b8a8
je 0xd68a
movq 0x6de60(%rip), %rbx     # 0x7b490
addq 0x6e279(%rip), %rbx     # 0x7b8b0
callq 0x114b2
cmpq %rax, %rbx
jae 0xd68a
callq 0x114b2
movq %rax, 0x6e263(%rip)     # 0x7b8b0
movq $0x0, 0x6e260(%rip) # 0x7b8b8
callq 0x114b2
movq %rax, 0x6e25c(%rip)     # 0x7b8c0
leaq 0xf626(%rip), %rsi      # 0x1cc91
leaq 0xf657(%rip), %rdx      # 0x1ccc9
movl $0x2, %edi
xorl %eax, %eax
callq 0x1a227
leaq 0xf630(%rip), %rdi      # 0x1ccb5
callq 0x12ce5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterCapturedCB
int pirebooterCapturedCB( char *strIn )
{
    static unsigned long lastTime = 0L;

    pirebooterConfig.timeLastProgress = apiTimeGet();
    pirebooterConfig.timeFirstIdle  = 0L;
    
    if (( pirebooterConfig.timeLastReboot + pirebooterConfig.rebootBusySec ) < apiTimeGet() ) {
	if ( (lastTime + 10L) < apiTimeGet() ) {
	    lastTime = apiTimeGet();
	    apiSaySys( pirebooterConfig.rebootWarning );
	}
    }
    return 0;
}

// Assembly:
pushq %rbx
callq 0x114b2
movq %rax, 0x6e225(%rip)     # 0x7b8c0
movq $0x0, 0x6e212(%rip) # 0x7b8b8
movq 0x6dde3(%rip), %rbx     # 0x7b490
addq 0x6e1fc(%rip), %rbx     # 0x7b8b0
callq 0x114b2
cmpq %rax, %rbx
jae 0xd6ed
movq 0x6ea03(%rip), %rbx     # 0x7c0c8
addq $0xa, %rbx
callq 0x114b2
cmpq %rax, %rbx
jae 0xd6ed
callq 0x114b2
movq %rax, 0x6e9e9(%rip)     # 0x7c0c8
leaq 0x6e1e2(%rip), %rdi     # 0x7b8c8
xorl %eax, %eax
callq 0x1316b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterActivityCB
int pirebooterActivityCB( char *strIn )
{
    if ( NULL != strstr( strIn, " killed " ) ) {
        if ( NULL != strstr( strIn, " with " ) ) {
            pirebooterConfig.timeLastProgress = apiTimeGet();
        }
    }
    return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1130a(%rip), %rsi     # 0x1ea06
callq 0x83b0
testq %rax, %rax
je 0xd726
leaq 0x1131d(%rip), %rsi     # 0x1ea2a
movq %rbx, %rdi
callq 0x83b0
testq %rax, %rax
je 0xd726
callq 0x114b2
movq %rax, 0x6e19a(%rip)     # 0x7b8c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterInstallPlugin
int pirebooterInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pirebooterInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( pirebooterConfig.pluginState == 0 ) return 0;

    // Install Event-driven CallBack hooks so the plugin gets
    // notified for various happenings.  A complete list is here,
    // but comment out what is not needed for your plug-in.
    // 
    eventsRegister( SISSM_EV_CLIENT_ADD,           pirebooterClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           pirebooterClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 pirebooterInitCB );
    eventsRegister( SISSM_EV_RESTART,              pirebooterRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            pirebooterMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           pirebooterGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             pirebooterGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          pirebooterRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            pirebooterRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   pirebooterCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             pirebooterPeriodicCB );
    eventsRegister( SISSM_EV_SHUTDOWN,             pirebooterShutdownCB );
    eventsRegister( SISSM_EV_ACTIVITY,             pirebooterActivityCB );

    return 0;
}

// Assembly:
pushq %rax
callq 0xd280
cmpl $0x0, 0x6d9e5(%rip)     # 0x7b480
je 0xdb7e
leaq -0x64a(%rip), %rsi      # 0xd45e
movl $0x3, %edi
callq 0xd08c
leaq -0x64d(%rip), %rsi      # 0xd46c
movl $0x4, %edi
callq 0xd08c
leaq -0x650(%rip), %rsi      # 0xd47a
movl $0x1, %edi
callq 0xd08c
leaq -0x639(%rip), %rsi      # 0xd4a2
movl $0x2, %edi
callq 0xd08c
leaq -0x647(%rip), %rsi      # 0xd4a5
movl $0x5, %edi
callq 0xd08c
leaq -0x63c(%rip), %rsi      # 0xd4c1
movl $0x6, %edi
callq 0xd08c
leaq -0x5d0(%rip), %rsi      # 0xd53e
movl $0x7, %edi
callq 0xd08c
leaq -0x55a(%rip), %rsi      # 0xd5c5
movl $0x8, %edi
callq 0xd08c
leaq -0x529(%rip), %rsi      # 0xd607
movl $0x9, %edi
callq 0xd08c
leaq -0x4b3(%rip), %rsi      # 0xd68e
movl $0xa, %edi
callq 0xd08c
leaq -0x40c(%rip), %rsi      # 0xd746
movl $0xb, %edi
callq 0xd08c
leaq -0x439(%rip), %rsi      # 0xd72a
movl $0xe, %edi
callq 0xd08c
leaq -0x483(%rip), %rsi      # 0xd6f1
movl $0x1c, %edi
callq 0xd08c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piprotect.c
// Function: piprotectDetectedCB
int piprotectDetectedCB( char *strIn )
{
    if ( errPlayerCount < PIPROTECT_MAXNUMNAMES ) {
        if ( NULL != strstr( strIn, PIPROTECTERRMATCH1 )) {
            strlcpy( errPlayerName[ errPlayerCount ], &strIn[nameCharOffset1], PIPROTECT_MAXNAMESIZE );
            strClean( errPlayerName[ errPlayerCount ] );
            strTrimInPlace( errPlayerName[ errPlayerCount++ ] );
            logPrintf( LOG_LEVEL_WARN, "piprotect", "Connect DetectedCB#1 ::%s::%d::",  errPlayerName[ errPlayerCount-1 ], errPlayerCount-1 );
        }
        else if ( NULL != strstr( strIn, PIPROTECTERRMATCH2 ) ) {
            strlcpy( errPlayerName[ errPlayerCount ], &strIn[nameCharOffset2], PIPROTECT_MAXNAMESIZE );
            strClean( errPlayerName[ errPlayerCount ] );
            strTrimInPlace( errPlayerName[ errPlayerCount++ ] );
            logPrintf( LOG_LEVEL_WARN, "piprotect", "Connect DetectedCB#2 ::%s::%d::",  errPlayerName[ errPlayerCount-1 ], errPlayerCount-1 );
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0xb40ae(%rip), %r15     # 0xc2d34
cmpq $0x1f, %r15
jg 0xed71
movq %rdi, %r14
leaq 0xe715(%rip), %rsi      # 0x1d3af
callq 0x83b0
testq %rax, %rax
je 0xecb9
leaq 0xe71f(%rip), %rbx      # 0x1d3ca
movl $0x4f, %eax
leaq 0xb4a89(%rip), %rcx     # 0xc3740
jmp 0xece4
leaq 0xe72a(%rip), %rsi      # 0x1d3ea
movq %r14, %rdi
callq 0x83b0
testq %rax, %rax
je 0xed71
leaq 0xe72b(%rip), %rbx      # 0x1d403
movl $0x4d, %eax
leaq 0xb4a60(%rip), %rcx     # 0xc3744
leaq (%r15,%r15,4), %rdi
shlq $0x4, %rdi
leaq 0xb404d(%rip), %r15     # 0xc2d40
addq %r15, %rdi
xorl %edx, %edx
cmpb $0x0, (%rcx)
cmoveq %rdx, %rax
addq %rax, %r14
movl $0x50, %edx
movq %r14, %rsi
callq 0xf038
movslq 0xb401e(%rip), %rax     # 0xc2d34
leaq (%rax,%rax,4), %rdi
shlq $0x4, %rdi
addq %r15, %rdi
callq 0xf65d
movslq 0xb4007(%rip), %rax     # 0xc2d34
leal 0x1(%rax), %ecx
movl %ecx, 0xb3ffe(%rip)     # 0xc2d34
leaq (%rax,%rax,4), %rdi
shlq $0x4, %rdi
addq %r15, %rdi
callq 0xf5e3
movslq 0xb3fe7(%rip), %r8      # 0xc2d34
decq %r8
leaq (%r8,%r8,4), %rcx
shlq $0x4, %rcx
addq %r15, %rcx
leaq 0xe530(%rip), %rsi      # 0x1d292
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1a227
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq