LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdGameModeProperty
int _cmdGameModeProperty( char *arg, char *arg2, char *passThru ) 
{ 
    int  errCode = 1;
    char statusIn[256], cmdOut[256];

    // snprintf( cmdOut, 256, "kick %s", steamID );
    if ( 0 != strlen( arg ) ) {
        if ( 0 != strlen( arg2 ) ) {
            apiGameModePropertySet( arg, arg2 );
        }
        strlcpy( statusIn, apiGameModePropertyGet( arg ), 256 );
        if ( 0 == strlen( statusIn ) ) 
           apiSaySys( "GMP Readback Error");
        else {
           if ( snprintf( cmdOut, 255, "'%s' is set to '%s'", arg, statusIn ) < 0 )
               logPrintf( LOG_LEVEL_WARN, "picladmin", "Overflow warning at _cmdGameModeProperty" );
           apiSaySys( cmdOut );
           errCode = 0;
        }
    }
    else {
        _stddResp( 1 );   // format error message to game
    }
    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc0b1
movq -0x10(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc005
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x176f0
leaq -0x120(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17720
movq -0x228(%rbp), %rdi
movq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x120(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xc056
leaq 0x17ccd(%rip), %rdi     # 0x23d1a
movb $0x0, %al
callq 0x17af0
jmp 0xc0af
leaq -0x220(%rbp), %rdi
movq -0x8(%rbp), %rcx
leaq -0x120(%rbp), %r8
movl $0xff, %esi
leaq 0x17cb9(%rip), %rdx     # 0x23d2d
movb $0x0, %al
callq 0x8180
cmpl $0x0, %eax
jge 0xc09a
movl $0x1, %edi
leaq 0x17bfb(%rip), %rsi     # 0x23c87
leaq 0x17cae(%rip), %rdx     # 0x23d41
movb $0x0, %al
callq 0x21bf0
leaq -0x220(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
movl $0x0, -0x1c(%rbp)
jmp 0xc0bb
movl $0x1, %edi
callq 0xa4d0
movl -0x1c(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1070, %rsp           # imm = 0x1070
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x1, -0x102c(%rbp)
leaq -0x1070(%rbp), %rdi
leaq 0x23caa(%rip), %rsi     # 0x2fdb0
movl $0x38, %edx
callq 0x8270
movq -0x8(%rbp), %rdi
leaq -0x1070(%rbp), %rsi
movl $0x1, %edx
callq 0x12360
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
je 0xc1a7
movq -0x18(%rbp), %rdi
leaq 0x1800c(%rip), %rsi     # 0x24158
callq 0x8390
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0xc1a5
movq -0x1028(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x17fa0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xc195
movl $0x0, -0x20(%rbp)
leaq -0x1020(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
jmp 0xc1a3
leaq 0x17c0e(%rip), %rdi     # 0x23daa
movb $0x0, %al
callq 0x17af0
jmp 0xc1a5
jmp 0xc1b5
leaq 0x17c11(%rip), %rdi     # 0x23dbf
movb $0x0, %al
callq 0x17af0
movl -0x20(%rbp), %eax
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc408
movq -0x8(%rbp), %rsi
leaq 0x17a93(%rip), %rdi     # 0x23e5c
callq 0x1ec70
callq 0x150c0
movq %rax, %rsi
leaq 0x17a9c(%rip), %rdi     # 0x23e79
callq 0x1ebf0
leaq 0x17a73(%rip), %rdi     # 0x23e5c
leaq 0x17321(%rip), %rsi     # 0x23711
callq 0x1ee50
movq %rax, %rsi
leaq 0x17a97(%rip), %rdi     # 0x23e96
movb $0x0, %al
callq 0x17af0
jmp 0xc439
leaq 0x17a4d(%rip), %rdi     # 0x23e5c
leaq 0x172fb(%rip), %rsi     # 0x23711
callq 0x1ec70
leaq 0x17a57(%rip), %rdi     # 0x23e79
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
leaq 0x17a85(%rip), %rdi     # 0x23eb7
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1730c(%rip), %rdi     # 0x23782
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xc4a0
leaq 0x17a3d(%rip), %rdi     # 0x23ec7
movsd 0x16b76(%rip), %xmm0    # 0x23008
callq 0x1ea50
xorl %edi, %edi
callq 0xa4d0
jmp 0xc4dc
movq -0x8(%rbp), %rsi
leaq 0x1aaad(%rip), %rdi     # 0x26f58
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xc4d0
leaq 0x17a08(%rip), %rdi     # 0x23ec7
xorps %xmm0, %xmm0
callq 0x1ea50
xorl %edi, %edi
callq 0xa4d0
jmp 0xc4da
movl $0x1, %edi
callq 0xa4d0
jmp 0xc4dc
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x193d0
movq %rax, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x122b0
movq -0x28(%rbp), %rdi
leaq 0x179ac(%rip), %rsi     # 0x23eda
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc55c
leaq -0x130(%rbp), %rdi
leaq 0x303f5(%rip), %rsi     # 0x3c940
addq $0x24010, %rsi          # imm = 0x24010
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x28(%rbp), %rdi
leaq 0x1797f(%rip), %rsi     # 0x23ee6
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc595
leaq -0x130(%rbp), %rdi
leaq 0x303bc(%rip), %rsi     # 0x3c940
addq $0x24410, %rsi          # imm = 0x24410
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x130(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x193d0
movq %rax, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x122b0
movq -0x28(%rbp), %rdi
leaq 0x178ec(%rip), %rsi     # 0x23eda
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc61c
leaq -0x130(%rbp), %rdi
leaq 0x30335(%rip), %rsi     # 0x3c940
addq $0x24810, %rsi          # imm = 0x24810
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x28(%rbp), %rdi
leaq 0x178bf(%rip), %rsi     # 0x23ee6
callq 0x8340
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xc655
leaq -0x130(%rbp), %rdi
leaq 0x302fc(%rip), %rsi     # 0x3c940
addq $0x24c10, %rsi          # imm = 0x24C10
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x130(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdWarn
int _cmdWarn( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    char outStr[256];

    strlcpy( outStr, picladminConfig.warnRusher, 256 );
    apiSaySys( outStr );

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x120(%rbp), %rdi
leaq 0x302a4(%rip), %rsi     # 0x3c940
addq $0x25010, %rsi          # imm = 0x25010
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x120(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdContact
int _cmdContact( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;
    char outStr[256];

    strlcpy( outStr, picladminConfig.contactInfo, 256 );
    apiSaySys( outStr );

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x120(%rbp), %rdi
leaq 0x30244(%rip), %rsi     # 0x3c940
addq $0x27810, %rsi          # imm = 0x27810
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x120(%rbp), %rdi
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/picladmin.c
// Function: cmdRules
int _cmdRules( char *arg, char *arg2, char *passThru ) 
{ 
    int errCode = 0;

    if (_rulesIndex == -1 ) {   // handled by periodic callback
        _rulesIndex = 0;
    }

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $-0x1, 0x24f52(%rip)    # 0x316a0
jne 0xc75a
movl $0x0, 0x24f46(%rip)     # 0x316a0
movl -0x1c(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x16ffc(%rip), %rdi     # 0x23782
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xc7b5
leaq 0x171d3(%rip), %rdi     # 0x2396d
xorps %xmm0, %xmm0
callq 0x1ea50
leaq 0x17748(%rip), %rdi     # 0x23ef1
movb $0x0, %al
callq 0x17af0
jmp 0xc840
movq -0x8(%rbp), %rsi
leaq 0x1a798(%rip), %rdi     # 0x26f58
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xc801
leaq 0x17199(%rip), %rdi     # 0x2396d
movsd 0x1682c(%rip), %xmm0    # 0x23008
callq 0x1ea50
leaq 0x17749(%rip), %rdi     # 0x23f31
movb $0x0, %al
callq 0x17af0
leaq 0x1711c(%rip), %rdi     # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
jmp 0xc83e
leaq 0x17165(%rip), %rdi     # 0x2396d
xorps %xmm0, %xmm0
callq 0x1ecf0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jne 0xc82e
jp 0xc82e
leaq 0x17738(%rip), %rdi     # 0x23f5d
movb $0x0, %al
callq 0x17af0
jmp 0xc83c
leaq 0x17734(%rip), %rdi     # 0x23f69
movb $0x0, %al
callq 0x17af0
jmp 0xc83e
jmp 0xc840
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x424(%rbp)
callq 0x18880
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0xce55
leaq -0x420(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
leaq -0x420(%rbp), %rdi
callq 0xce70
movl -0x424(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl $0x1, -0x124(%rbp)
movl $0x0, -0x130(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x128(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcfa0
movl $0x0, -0x124(%rbp)
xorl %eax, %eax
cmpl -0x130(%rbp), %eax
jne 0xcf9e
leaq -0x120(%rbp), %rdi
callq 0x122b0
movl $0x0, -0x12c(%rbp)
cmpl $0x4, -0x12c(%rbp)
jge 0xcf84
movq -0x10(%rbp), %rdi
movl -0x128(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
leaq 0x17251(%rip), %rdx     # 0x24158
callq 0x122d0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0xcf24
movl $0x1, -0x130(%rbp)
jmp 0xcf84
movq -0x18(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xcf43
movl $0x1, -0x130(%rbp)
jmp 0xcf84
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xff, %edx
callq 0x81b0
leaq -0x120(%rbp), %rdi
leaq 0x171f2(%rip), %rsi     # 0x24158
movl $0xff, %edx
callq 0x81b0
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0xcede
leaq -0x120(%rbp), %rsi
leaq 0x19cfa(%rip), %rdi     # 0x26c8c
movb $0x0, %al
callq 0x17af0
jmp 0xceba
jmp 0xcfa0
movl -0x124(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x424(%rbp)
callq 0x18c00
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0xd005
leaq -0x420(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
leaq -0x420(%rbp), %rdi
callq 0xce70
movl -0x424(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x424(%rbp)
movl $0x1, %edi
callq 0x18de0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0xd07a
leaq -0x420(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
leaq -0x420(%rbp), %rdi
callq 0xce70
movl -0x424(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x15eb0
callq 0x16360
leaq 0x17036(%rip), %rdi     # 0x240f2
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16fd2(%rip), %rsi     # 0x240cf
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0xd11a
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x18020
movl %eax, -0x1c(%rbp)
leaq 0x16fdd(%rip), %rdi     # 0x24109
movb $0x0, %al
callq 0x17af0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x16958(%rip), %rdi     # 0x23ab3
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
leaq 0x16902(%rip), %rdi     # 0x23a6d
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
leaq 0x16910(%rip), %rdi     # 0x23a8b
movl $0x1, %esi
callq 0x1ebf0
leaq 0x16f8c(%rip), %rdi     # 0x24118
movb $0x0, %al
callq 0x17af0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x58099(%rip)     # 0x65d5c
jne 0xdce9
movl $0x0, 0x5808d(%rip)     # 0x65d5c
leaq 0x15e7c(%rip), %rdi     # 0x23b52
movb $0x0, %al
callq 0x17af0
leaq 0x15e96(%rip), %rdi     # 0x23b7a
callq 0x17510
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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdd50
cmpl $0x2, 0x58044(%rip)     # 0x65d5c
jne 0xdd3e
movl $0x0, 0x58038(%rip)     # 0x65d5c
leaq 0x15e27(%rip), %rdi     # 0x23b52
movb $0x0, %al
callq 0x17af0
leaq 0x15e41(%rip), %rdi     # 0x23b7a
callq 0x17510
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/picladmin.c
// Function: resetP2PVars
static void _resetP2PVars( void )
{
    p2pSetF( "piantirush.p2p.fast", 0.0 );
    p2pSetF( "api.p2p.sayDisable", 0.0 );

    // Don't reset allowin because the player may join between map change
    //
    // p2pSetS( "picladmin.p2p.allowInPattern", "" );
    // p2pSetL( "picladmin.p2p.allowTimeStart", 0L );

    // Release the bot ownership - if this module (admin) change the bot
    // setting it is "owned" by this module until start of next map
    //
    p2pSetL( "picladmin.p2p.botAdminControl", 0L );
    p2pSetL( "picladmin.p2p.botAdminControlDifficulty", 0L );

    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x15c12(%rip), %rdi     # 0x2396d
xorps %xmm0, %xmm0
callq 0x1ea50
leaq 0x1615d(%rip), %rdi     # 0x23ec7
xorps %xmm0, %xmm0
callq 0x1ea50
leaq 0x15cf4(%rip), %rdi     # 0x23a6d
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
leaq 0x15d2a(%rip), %rdi     # 0x23ab3
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $-0x1, 0x238cd(%rip)    # 0x316a0
je 0xde45
cmpl $0x0, 0x57b74(%rip)     # 0x65950
je 0xde45
movl 0x57f7c(%rip), %eax     # 0x65d60
addl $0x1, %eax
movl %eax, 0x57f73(%rip)     # 0x65d60
cmpl 0x57b5d(%rip), %eax     # 0x65950
jl 0xde43
movl $0x0, 0x57f61(%rip)     # 0x65d60
movl 0x2389b(%rip), %eax     # 0x316a0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x23890(%rip)     # 0x316a0
cltq
leaq 0x2eb27(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
shlq $0xa, %rax
addq %rax, %rdi
movb $0x0, %al
callq 0x17af0
cmpl $0x5, 0x2386b(%rip)     # 0x316a0
jl 0xde41
movl $0xffffffff, 0x2385f(%rip) # imm = 0xFFFFFFFF
jmp 0xde43
jmp 0xde45
cmpl $0x2, 0x57f10(%rip)     # 0x65d5c
je 0xde57
cmpl $0x1, 0x57f07(%rip)     # 0x65d5c
jne 0xde8a
callq 0x17fe0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xde88
movl $0x0, 0x57eee(%rip)     # 0x65d5c
leaq 0x15cdd(%rip), %rdi     # 0x23b52
movb $0x0, %al
callq 0x17af0
leaq 0x15cf7(%rip), %rdi     # 0x23b7a
callq 0x17510
jmp 0xde8a
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/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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x20(%rbp), %rdi
callq 0x122b0
leaq -0x140(%rbp), %rdi
leaq 0x1868e(%rip), %rsi     # 0x269ef
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x140(%rbp), %rdi
leaq 0x2e5c7(%rip), %rsi     # 0x3c940
addq $0x3c04, %rsi           # imm = 0x3C04
movl $0x100, %edx            # imm = 0x100
callq 0x11aa0
movq -0x8(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x8390
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe42f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %r8d
movl $0x28, %esi
movl $0x29, %edx
callq 0x19200
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0xe42d
movq -0x28(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x148(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x20(%rbp), %rdi
callq 0x12450
movq -0x20(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xe42b
movl $0x0, -0x38(%rbp)
jmp 0xe42d
jmp 0xe42f
movl -0x38(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x20(%rbp), %rdi
callq 0x122b0
movq -0x8(%rbp), %rdi
leaq 0x16275(%rip), %rsi     # 0x246f0
callq 0x8390
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xe55b
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xe559
movq -0x38(%rbp), %rdi
leaq 0x2e48a(%rip), %rsi     # 0x3c940
addq $0x3c04, %rsi           # imm = 0x3C04
callq 0x8390
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0xe557
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0xe555
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x3204f(%rip), %rdi     # 0x40544
callq 0x8110
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x11bc0
movq -0x20(%rbp), %rdi
callq 0x12450
movq -0x18(%rbp), %rdi
leaq 0x161d2(%rip), %rsi     # 0x246f4
movl $0x12, %edx
callq 0x11bc0
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2, %edi
leaq 0x15740(%rip), %rsi     # 0x23c87
leaq 0x161b8(%rip), %rdx     # 0x24706
movb $0x0, %al
callq 0x21bf0
jmp 0xe557
jmp 0xe559
jmp 0xe55b
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x810, %rsp            # imm = 0x810
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rdx
leaq -0x810(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0xe320
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xe5fc
movq -0x8(%rbp), %rcx
movl $0x3, %edi
leaq 0x16177(%rip), %rsi     # 0x2472a
leaq 0x16181(%rip), %rdx     # 0x2473b
movb $0x0, %al
callq 0x21bf0
leaq -0x410(%rbp), %rcx
leaq -0x810(%rbp), %r8
movl $0x3, %edi
leaq 0x1614f(%rip), %rsi     # 0x2472a
leaq 0x16168(%rip), %rdx     # 0x2474a
movb $0x0, %al
callq 0x21bf0
leaq -0x810(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0xdf60
xorl %eax, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
callq 0x8a90
movq %rax, %rdi
callq 0x9370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x15fa7(%rip), %rsi     # 0x247ae
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x57857(%rip)     # 0x66070
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0xe8b8
leaq -0x410(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x100, %esi            # imm = 0x100
leaq 0x15f85(%rip), %rdx     # 0x247c5
movb $0x0, %al
callq 0x8180
movslq -0xc(%rbp), %rcx
leaq 0x5781e(%rip), %rax     # 0x66070
addq $0x4, %rax
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, -0x418(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
leaq 0x14e9b(%rip), %rdx     # 0x23711
callq 0x9430
movq -0x418(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movslq -0xc(%rbp), %rax
leaq 0x577d6(%rip), %rdi     # 0x66070
addq $0x4, %rdi
shlq $0xa, %rax
addq %rax, %rdi
callq 0x127c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe820
movq -0x8(%rbp), %rdi
leaq 0x15f18(%rip), %rsi     # 0x247db
leaq 0x14e47(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x57797(%rip), %rdi     # 0x66070
addq $0x19004, %rdi          # imm = 0x19004
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
callq 0x93f0
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/events.c
// Function: eventsInit
int eventsInit( void )
{
    int errCode = 0;
    int i, j;

    // zero out the callback functions
    //
    for ( i=0; i<SISSM_MAXPLUGINS; i++ )
        for ( j=0; j<SISSM_MAXEVENTS; j++ )
            eventsCallbackFunctions[i][j] = NULL;

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0xee4b
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0xee3e
movslq -0x8(%rbp), %rcx
leaq 0x70660(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xee0f
jmp 0xee40
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xee02
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0xeee6
movslq -0x14(%rbp), %rcx
leaq 0x2282b(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq 0x14d65(%rip), %rsi     # 0x23bfc
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xeea6
jmp 0xeee6
movslq -0x14(%rbp), %rcx
leaq 0x227ff(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xeed9
movslq -0x14(%rbp), %rcx
leaq 0x227e6(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xeee6
jmp 0xeedb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xee74
cmpl $-0x1, -0x1c(%rbp)
je 0xef4c
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0xef4a
movslq -0x1c(%rbp), %rcx
leaq 0x7057c(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xef3d
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x7055b(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
jmp 0xef4a
jmp 0xef3f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeef3
jmp 0xef4c
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0xeff6
movslq -0x14(%rbp), %rcx
leaq 0x2271b(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq 0x14c55(%rip), %rsi     # 0x23bfc
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xefb6
jmp 0xeff6
movslq -0x14(%rbp), %rcx
leaq 0x226ef(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xefe9
movslq -0x14(%rbp), %rcx
leaq 0x226d6(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xeff6
jmp 0xefeb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xef84
cmpl $-0x1, -0x1c(%rbp)
je 0xf05d
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0xf05b
movslq -0x1c(%rbp), %rcx
leaq 0x7046c(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0xf04e
movslq -0x1c(%rbp), %rcx
leaq 0x7044c(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
jmp 0xf050
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf003
jmp 0xf05d
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0xf1cc
movslq -0xc(%rbp), %rcx
leaq 0x22611(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xf0be
jmp 0xf1be
movslq -0xc(%rbp), %rcx
leaq 0x225e7(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq 0x14b21(%rip), %rsi     # 0x23bfc
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xf0ed
jmp 0xf1cc
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x225b4(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xf190
movslq -0xc(%rbp), %rcx
leaq 0x2258f(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xf18e
movl $0x0, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0xf18c
movslq -0x14(%rbp), %rax
leaq 0x70334(%rip), %rcx     # 0x7f480
shlq $0x9, %rax
addq %rax, %rcx
movslq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rcx,%rdx,8), %rax
je 0xf17f
movslq -0x14(%rbp), %rcx
leaq 0x70316(%rip), %rax     # 0x7f480
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0xf181
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf13b
jmp 0xf18e
jmp 0xf1cc
movslq -0xc(%rbp), %rcx
leaq 0x22515(%rip), %rax     # 0x316b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0x14a4f(%rip), %rdi     # 0x23bfc
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xf1bc
jmp 0xf1cc
jmp 0xf1be
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf08a
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x150c0
movq %rax, 0x74448(%rip)     # 0x838b0
callq 0x150c0
movq %rax, 0x7444c(%rip)     # 0x838c0
movq $0x0, 0x74439(%rip) # 0x838b8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, 0x743d1(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x743cd(%rip)     # 0x838c0
movq 0x743b6(%rip), %rax     # 0x838b0
addq 0x73f8f(%rip), %rax     # 0x83490
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xf55f
callq 0x150c0
movq %rax, 0x7438e(%rip)     # 0x838b0
movq $0x0, 0x7438b(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x74387(%rip)     # 0x838c0
movl $0x2, %edi
leaq 0x15754(%rip), %rsi     # 0x24c99
leaq 0x15758(%rip), %rdx     # 0x24ca4
movb $0x0, %al
callq 0x21bf0
leaq 0x15763(%rip), %rdi     # 0x24cbd
callq 0x17510
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, 0x74331(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x7432d(%rip)     # 0x838c0
cmpq $0x0, 0x7430d(%rip)     # 0x838a8
jne 0xf60b
movq 0x7430c(%rip), %rax     # 0x838b0
addq 0x73ee5(%rip), %rax     # 0x83490
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xf609
callq 0x150c0
movq %rax, 0x742e4(%rip)     # 0x838b0
movq $0x0, 0x742e1(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x742dd(%rip)     # 0x838c0
movl $0x2, %edi
leaq 0x156aa(%rip), %rsi     # 0x24c99
leaq 0x156ae(%rip), %rdx     # 0x24ca4
movb $0x0, %al
callq 0x21bf0
leaq 0x156b9(%rip), %rdi     # 0x24cbd
callq 0x17510
jmp 0xf60b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)