LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piprotect.c
// Function: piprotectPeriodicCB
int piprotectPeriodicCB( char *strIn )
{
    int i, j = 0;
    static char kickName[ PIPROTECT_MAXNAMESIZE ];

    // logPrintf( LOG_LEVEL_WARN, "piprotect", "PERIODIC in counterattack %d", apiIsCounterAttack() );

    // Step 0:  Init
    //
    strclr( kickName );

    // Step 1:  analyze the table 
    //
    if ( errPlayerCount > piprotectConfig.countThreshold ) {

        // get the first name from the list
        strlcpy( kickName, errPlayerName[0], PIPROTECT_MAXNAMESIZE );

        // loop through all stored names and count the matches
        for (i = 1; i<errPlayerCount; i++ ) {

            // match counter
            if (0 == strcmp( errPlayerName[i], kickName )) j++;
            // if crash is imminent, break for the next phase (kick)
            if (j > piprotectConfig.countThreshold)        break;
        }
    }

    // Step 2:  kick bad connectors, if any
    //
    if ( j > piprotectConfig.countThreshold ) {
        apiKick( kickName, piprotectConfig.kickReason );
        logPrintf( LOG_LEVEL_WARN, "piprotect", "**System internal error - protective kick by name ::%s::", kickName );
    }

    // Step 3:  reset the analysis table
    //
    errPlayerCount  = 0;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xb49c8(%rip), %rdi     # 0xc3750
callq 0xf4dd
movl 0xb3fa1(%rip), %eax     # 0xc2d34
xorl %ebp, %ebp
cmpl 0x95b8d(%rip), %eax     # 0xa4928
jle 0xee02
leaq 0xb49ac(%rip), %rdi     # 0xc3750
leaq 0xb3f95(%rip), %rsi     # 0xc2d40
movl $0x50, %edx
callq 0xf038
movslq 0xb3f78(%rip), %r15     # 0xc2d34
cmpq $0x2, %r15
jl 0xee02
movl 0x95b5f(%rip), %r12d    # 0xa4928
addq $-0x2, %r15
xorl %ebp, %ebp
leaq 0xb3fba(%rip), %rbx     # 0xc2d90
leaq 0xb4973(%rip), %r14     # 0xc3750
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8220
cmpl $0x1, %eax
adcl $0x0, %ebp
subq $0x1, %r15
setb %al
cmpl %r12d, %ebp
jg 0xee02
addq $0x50, %rbx
testb %al, %al
je 0xeddd
cmpl 0x95b20(%rip), %ebp     # 0xa4928
jle 0xee3d
leaq 0xb493f(%rip), %rbx     # 0xc3750
leaq 0x95b18(%rip), %rsi     # 0xa4930
movq %rbx, %rdi
callq 0x13412
leaq 0xe46b(%rip), %rsi      # 0x1d292
leaq 0xe5f5(%rip), %rdx      # 0x1d423
movl $0x1, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1a227
movl $0x0, 0xb3eed(%rip)     # 0xc2d34
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/piprotect.c
// Function: piprotect_fakeMain
void piprotect_fakeMain( void )
{
    int i;
    char strIn[255];

    // init sim
    nameCharOffset1 = (int) strlen( PIPROTECTERRMSG1 ) + 1;
    nameCharOffset2 = (int) strlen( PIPROTECTERRMSG2 ) + 1;

    blackOutCounter = 0;
    errPlayerCount  = 0;

    for ( i = 0; i<PIPROTECT_MAXNUMNAMES; i++ )
        strclr( errPlayerName[ i ] );

    piprotectConfig.pluginState = 1;
    piprotectConfig.countThreshold = 3;
    piprotectConfig.blackoutWindowSec = 3;

    strcpy(piprotectConfig.kickReason, "test" );

    // run

    for (i = 0; i<1000; i++ ) {
        strcpy( strIn, "[2022.05.28-02.26.24:185][ 38]LogGameMode: Verbose: RestartPlayerAtPlayerStart testPlayerName" );
        piprotectDetectedCB( strIn );
        strcpy( strIn, "[2022.06.04-20.54.13:643][ 48]LogGameMode: Verbose: RestartPlayerAtTransform testPlayerName" );
        piprotectDetectedCB( strIn );
    }
    piprotectPeriodicCB( strIn );
    piprotectPeriodicCB( strIn );
    piprotectPeriodicCB( strIn );
 
    return;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movb $0x1, %al
movb %al, 0xb4841(%rip)      # 0xc3740
movb %al, 0xb483f(%rip)      # 0xc3744
movl $0x0, 0xb3e25(%rip)     # 0xc2d34
xorl %ebx, %ebx
leaq 0xb3e28(%rip), %r14     # 0xc2d40
leaq (%r14,%rbx), %rdi
callq 0xf4dd
addq $0x50, %rbx
cmpq $0xa00, %rbx            # imm = 0xA00
jne 0xef18
movl $0x1, 0x959e8(%rip)     # 0xa4920
movabsq $0x300000003, %rax      # imm = 0x300000003
movq %rax, 0x959df(%rip)     # 0xa4928
movl $0x74736574, 0x959dd(%rip) # imm = 0x74736574
movb $0x0, 0x959da(%rip)     # 0xa4934
movl $0x3e8, %ebp            # imm = 0x3E8
leaq 0xe4fb(%rip), %rbx      # 0x1d461
movq %rsp, %r14
leaq 0xe54f(%rip), %r15      # 0x1d4bf
movl $0x5e, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8290
movq %r14, %rdi
callq 0xec7a
movl $0x5c, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8290
movq %r14, %rdi
callq 0xec7a
decl %ebp
jne 0xef70
callq 0xed79
callq 0xed79
callq 0xed79
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/bsd.c
// Function: strlcat
size_t
strlcat(char *dst, const char *src, size_t siz)
{
        char *d = dst;
        const char *s = src;
        size_t n = siz;
        size_t dlen;

        /* Find the end of dst and adjust bytes left but don't go past end */
        while (n-- != 0 && *d != '\0')
                d++;
        dlen = d - dst;
        n = siz - dlen;

        if (n == 0)
                return(dlen + strlen(s));
        while (*s != '\0') {
                if (n != 1) {
                        *d++ = *s;
                        n--;
                }
                s++;
        }
        *d = '\0';

        return(dlen + (s - src));        /* count does not include NUL */
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
testq %rdx, %rdx
je 0xefe7
leaq (%rdi,%rdx), %rax
movq %rdx, %r8
movq %rdi, %rcx
cmpb $0x0, (%rcx)
je 0xefe7
incq %rcx
decq %r8
jne 0xefd7
movq %rax, %rcx
movq %rcx, %rbx
subq %rdi, %rbx
subq %rbx, %rdx
je 0xf02b
movb (%rsi), %dil
movq %rsi, %rax
testb %dil, %dil
je 0xf023
movl $0x1, %r8d
cmpq $0x1, %rdx
jne 0xf00e
movq %r8, %rdx
jmp 0xf017
movb %dil, (%rcx)
incq %rcx
decq %rdx
movb 0x1(%rax), %dil
incq %rax
testb %dil, %dil
jne 0xf003
movb $0x0, (%rcx)
subq %rsi, %rax
jmp 0xf033
movq %rsi, %rdi
callq 0x8120
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/ftrack.c
// Function: ftrackGetFilename
static int ftrackGetFilename( int fp, char *fileName )
{
    int     errCode = 1;
    char    proclnk[0x0fff];
    int     fNumber;
    ssize_t sizeName;

    strclr( fileName );
    // ssize_t r;
    if ( fp != -1 ) {
        errCode = 0;
        fNumber = fp;
        snprintf(proclnk, 0x0fff, "/proc/self/fd/%d", fNumber);
        sizeName = readlink(proclnk, fileName, 0x0fff);
        if ( sizeName > 0 ) {
            errCode = 0;
            fileName[ sizeName ] = 0;
        }
    }
    return( errCode );
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movl %edi, %r14d
movq %rsi, %rdi
callq 0xf4dd
cmpl $-0x1, %r14d
je 0xf18a
leaq 0xe4ae(%rip), %rdx      # 0x1d606
xorl %ebp, %ebp
movq %rsp, %r15
movl $0xfff, %esi            # imm = 0xFFF
movq %r15, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x8190
movl $0xfff, %edx            # imm = 0xFFF
movq %r15, %rdi
movq %rbx, %rsi
callq 0x80e0
testq %rax, %rax
jle 0xf18f
movb $0x0, (%rbx,%rax)
jmp 0xf18f
movl $0x1, %ebp
movl %ebp, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/ftrack.c
// Function: _ftrack_main
int __ftrack_main()
{
    ftrackObj *ftp;
    int stat;
    char strBuffer[1024];

    logPrintfInit( LOG_LEVEL_RAWDUMP, "zzz_delme.log", 1 );


    // ftp = ftrackOpen( "zzz_test.txt" );
    ftp = ftrackOpen( "C:/Program Files (x86)/Steam/steamapps/common/sandstorm_server/Insurgency/Saved/Logs/Insurgency.log" );

    if ( ftp == NULL ) {
        printf("\nOpen error\n");
        exit( 1 );
    }

    while ( 1 == 1 ) {
        stat = ftrackTailOfFile( ftp, strBuffer, 1024, 0 );
        if ( stat == 0 ) {
            printf("\n::%ld::%s::\n", _ftrackGetFileSize(ftp), strBuffer );
        }
        else {
            ftrackResync( ftp );
            usleep( 100000 );
        }
        
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x490, %rsp            # imm = 0x490
leaq 0xe1d1(%rip), %rsi      # 0x1d586
movl $0x4, %edi
movl $0x1, %edx
callq 0x1a1fc
leaq 0xe1c9(%rip), %rdi      # 0x1d594
callq 0xf098
testq %rax, %rax
je 0xf43d
movq %rax, %rbx
movq %rax, %r14
addq $0x404, %r14            # imm = 0x404
leaq 0x90(%rsp), %r15
movq %rsp, %r12
leaq 0xe204(%rip), %r13      # 0x1d5f8
movq %rbx, %rdi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0xf2f6
testl %eax, %eax
je 0xf41e
movq %rbx, %rdi
callq 0xf1c6
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x83f0
jmp 0xf3f4
movq %r14, %rdi
movq %r12, %rsi
callq 0x8280
movq 0x30(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8180
jmp 0xf3f4
leaq 0xe1d3(%rip), %rdi      # 0x1d617
callq 0x8090
movl $0x1, %edi
callq 0x8370
nop
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: computeElapsedTime
char *computeElapsedTime( unsigned long timeMark, unsigned long timeNow )
{
    static char retElapsedString[256];
    unsigned long timeElapsed, timeHours, timeMinutes, timeSeconds;

    if ( timeMark >= timeNow ) {
        strclr( retElapsedString );
    }
    else {
        timeElapsed = timeNow - timeMark;
        timeHours   = timeElapsed / 3600L;
        timeMinutes = (timeElapsed - (timeHours * 3600L)) / 60L;
        timeSeconds = (timeElapsed - (timeHours * 3600L + timeMinutes * 60L)) % 60L;
        snprintf( retElapsedString, 256, "%ld:%02ld:%02ld", timeHours, timeMinutes, timeSeconds );
    }
    return( retElapsedString );
}

// Assembly:
subq %rdi, %rsi
jbe 0xf4ce
pushq %rax
movq %rsi, %rax
shrq $0x4, %rax
movabsq $0x91a2b3c4d5e6f81, %rcx # imm = 0x91A2B3C4D5E6F81
mulq %rcx
movq %rdx, %rcx
shrq $0x3, %rcx
imulq $0xe10, %rcx, %rax      # imm = 0xE10
subq %rax, %rsi
movabsq $-0x7777777777777777, %rdi # imm = 0x8888888888888889
movq %rsi, %rax
mulq %rdi
movq %rdx, %r8
shrq $0x5, %r8
imulq $-0x3c, %r8, %r9
addq %rsi, %r9
movq %r9, %rax
mulq %rdi
shrq $0x5, %rdx
imulq $0x3c, %rdx, %rax
subq %rax, %r9
leaq 0xb42eb(%rip), %rdi     # 0xc37a0
leaq 0xe167(%rip), %rdx      # 0x1d623
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x8190
addq $0x8, %rsp
jmp 0xf4d5
movb $0x0, 0xb42cb(%rip)     # 0xc37a0
leaq 0xb42c4(%rip), %rax     # 0xc37a0
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: getWord
char *getWord( char *strIn, int wordIndex, char *delim )
{
    static char retStr[BUFSIZE];

    char  *pch = NULL;
    int   i = 0;

    retStr[BUFSIZE-1] = 0;
    strlcpy( retStr, strIn, BUFSIZE-2);
    pch = strtok( retStr, delim );
    while (pch != NULL) {
        if ( i++ == wordIndex ) {
            break;
        }
        pch = strtok( NULL, delim );
    }
    return pch;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
movb $0x0, 0xb83ab(%rip)     # 0xc789f
leaq 0xb43a5(%rip), %r14     # 0xc38a0
movl $0x3ffe, %edx           # imm = 0x3FFE
movq %r14, %rdi
callq 0xf038
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8340
testq %rax, %rax
sete %cl
testl %ebp, %ebp
sete %dl
orb %cl, %dl
jne 0xf53d
decl %ebp
xorl %edi, %edi
movq %rbx, %rsi
callq 0x8340
subl $0x1, %ebp
setb %cl
testq %rax, %rax
je 0xf53d
testb %cl, %cl
je 0xf524
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: foundMatch
int foundMatch( char *line, char *table[], int caseConvert )
{
    int foundMe = 0;
    int p;
    static char lineCopy[4096];

    strlcpy( lineCopy, line, 4096 );

    if ( caseConvert ) {
        for (p=0; p<4096; p++) {
           lineCopy[p] = tolower(line[p]);
           if (line[p] == 0) break;
        }
        lineCopy[4095] = 0;
    }

    p = 0;
    while (table[p][0] != '*') {
        if (NULL != strstr( lineCopy, table[p] )) {
            foundMe = 1;
            break;
        }
        p++;
    }
    return( foundMe );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb8347(%rip), %r15     # 0xc78a0
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rsi
callq 0xf038
testl %ebp, %ebp
je 0xf5a3
xorl %r12d, %r12d
callq 0x83d0
movq (%rax), %rcx
movsbq (%r14,%r12), %rdx
movb (%rcx,%rdx,4), %cl
movb %cl, (%r12,%r15)
cmpb $0x0, (%r14,%r12)
je 0xf59c
leaq 0x1(%r12), %rcx
cmpq $0xfff, %r12            # imm = 0xFFF
movq %rcx, %r12
jne 0xf575
movb $0x0, 0xb92fc(%rip)     # 0xc889f
movq (%rbx), %rsi
xorl %ebp, %ebp
cmpb $0x2a, (%rsi)
je 0xf5d8
addq $0x8, %rbx
leaq 0xb82e8(%rip), %r14     # 0xc78a0
movq %r14, %rdi
callq 0x83b0
testq %rax, %rax
jne 0xf5d3
movq (%rbx), %rsi
addq $0x8, %rbx
cmpb $0x2a, (%rsi)
jne 0xf5b8
jmp 0xf5d8
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: strTrimInPlace
void strTrimInPlace(char * s)
{
    char * p = s;
    int l = (int) strlen( p );

    while ( isspace(p[l - 1]) )  p[--l] = 0;
    while ( * p && isspace(*p) ) ++p, --l;

    memmove(s, p, l + 1);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8120
movq %rax, %r14
callq 0x83e0
movq (%rax), %rcx
movslq %r14d, %rdx
movsbq -0x1(%rbx,%rdx), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xf629
movslq %r14d, %rdx
leaq -0x1(%rdx), %r14
movb $0x0, -0x1(%rbx,%rdx)
movq (%rax), %rcx
movsbq -0x2(%rbx,%rdx), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
movq %r14, %rdx
jne 0xf60d
movb (%rbx), %al
movq %rbx, %rsi
testb %al, %al
je 0xf648
movsbq %al, %rax
testb $0x20, 0x1(%rcx,%rax,2)
je 0xf648
decl %r14d
movb 0x1(%rsi), %al
incq %rsi
jmp 0xf62e
incl %r14d
movslq %r14d, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8300
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: strToLowerInPlace
void strToLowerInPlace(char * s)
{
    register int i;
    int j;
    j = (int) strlen( s );
    for (i=0; i<j; i++) s[i] = tolower(s[i]);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8120
movq %rax, %r14
testl %r14d, %r14d
jle 0xf709
callq 0x83d0
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq (%rbx,%rcx), %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0xf6f3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: reformatIP
char *reformatIP( char *originalIP )
{
    static char expandedIP[256];
    unsigned int n1, n2, n3, n4;
    strlcpy( expandedIP,  "000.000.000.000", 256 );
    if ( 4 == sscanf( originalIP, "%d.%d.%d.%d", &n1, &n2, &n3, &n4 )) {
        if ((n1<256) && (n2<256) && (n3<256) && (n4<256)) {
            snprintf( expandedIP, 256, "%03d.%03d.%03d.%03d", n1, n2, n3, n4 );
        }
    }
    return( expandedIP );
}

// Assembly:
subq $0x18, %rsp
movups 0xbadf(%rip), %xmm0     # 0x1b1fb
movaps %xmm0, 0xb917d(%rip)    # 0xc88a0
leaq 0xdf09(%rip), %rsi      # 0x1d633
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
xorl %eax, %eax
callq 0x82d0
cmpl $0x4, %eax
jne 0xf7a4
movl 0x14(%rsp), %ecx
movl $0x100, %edx            # imm = 0x100
cmpl %edx, %ecx
setb %al
movl 0x10(%rsp), %r8d
cmpl %edx, %r8d
setb %sil
andb %al, %sil
movl 0xc(%rsp), %r9d
cmpl %edx, %r9d
setb %dil
movl 0x8(%rsp), %eax
cmpl %edx, %eax
setb %dl
andb %dil, %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0xf7a4
movl %eax, (%rsp)
leaq 0xb910f(%rip), %rdi     # 0xc88a0
leaq 0xdea7(%rip), %rdx      # 0x1d63f
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x8190
leaq 0xb90f5(%rip), %rax     # 0xc88a0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: isReadable
int isReadable( char *fileName )
{
    int fileReadOk = 0;
    FILE *fpr;
    char tmpBuffer[16];

    if ( NULL != (fpr = fopen( fileName, "rb" ))) {
        if ( 1 == fread( tmpBuffer, 1, 1, fpr ) ) 
            fileReadOk = 1;
        fclose( fpr );
    }
    return fileReadOk;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0xde96(%rip), %rsi      # 0x1d653
callq 0x8320
testq %rax, %rax
je 0xf7f3
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x80b0
xorl %ebp, %ebp
cmpq $0x1, %rax
sete %bpl
movq %rbx, %rdi
callq 0x8100
jmp 0xf7f5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: replaceDoubleColonWithBell
void  replaceDoubleColonWithBell( char *strInOut )
{
    int i;

    if ( strlen( strInOut ) > 1  ) {
        for (i=0; i< (int)strlen( strInOut )-1 ; i++) {
            if (( strInOut[i] == ':' ) && ( strInOut[i+1] == ':'))  {
                strInOut[i] = '\007';
                strInOut[i+1] = '\007';
            }
        }
    }
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8120
cmpq $0x2, %rax
jb 0xf84a
movq %rbx, %rdi
callq 0x8120
cmpl $0x2, %eax
jl 0xf84a
xorl %r14d, %r14d
cmpb $0x3a, (%rbx,%r14)
jne 0xf836
cmpb $0x3a, 0x1(%rbx,%r14)
jne 0xf836
movw $0x707, (%rbx,%r14)     # imm = 0x707
incq %r14
movq %rbx, %rdi
callq 0x8120
decl %eax
cltq
cmpq %rax, %r14
jl 0xf820
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/util.c
// Function: debugPoke
int debugPoke( char *fileName, int *valueOut )
{
    int errCode = 1;
    FILE *fpr;
    static char tmpBuf[256];

    if ( NULL != (fpr = fopen( fileName, "rt" )) ) {
        if ( NULL != fgets( tmpBuf, 256, fpr ) ) {
            if ( 1 == sscanf( tmpBuf, "%d", valueOut )) {
                errCode = 0;
            }
        }
        fclose( fpr );
    }
    return( errCode ); 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0xc633(%rip), %rsi      # 0x1be93
callq 0x8320
testq %rax, %rax
je 0xf8a9
movq %rax, %rbx
leaq 0xb912c(%rip), %rdi     # 0xc89a0
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x8200
testq %rax, %rax
je 0xf8b0
leaq 0xb9113(%rip), %rdi     # 0xc89a0
leaq 0xc839(%rip), %rsi      # 0x1c0cd
movq %r14, %rdx
xorl %eax, %eax
callq 0x82d0
xorl %ebp, %ebp
cmpl $0x1, %eax
setne %bpl
jmp 0xf8b5
movl $0x1, %ebp
jmp 0xf8bd
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x8100
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmCreate
alarmObj *alarmCreate( int (*alarmCBfunc)( char * ) )
{
    alarmObj *aPtr = NULL;
    int i;

    aPtr = calloc( 1, sizeof( alarmObj ));
    if ( aPtr != NULL ) {
        aPtr->alarmTime = 0L;
        aPtr->alarmCallbackFunction = alarmCBfunc;

        for (i = 0; i<SISSM_MAXALARMS; i++) {
            if ( alarmTable[ i ] == NULL ) {
                alarmTable[ i ] = aPtr;
                aPtr->usedIndex = i;
                break;
            }
        }
    }
    return aPtr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x8210
testq %rax, %rax
je 0xf921
movq $0x0, (%rax)
movq %rbx, 0x8(%rax)
leaq 0xb919f(%rip), %rdx     # 0xc8aa0
xorl %ecx, %ecx
cmpq $0x0, (%rdx)
je 0xf91b
incq %rcx
addq $0x8, %rdx
cmpq $0x80, %rcx
jne 0xf903
jmp 0xf921
movq %rax, (%rdx)
movl %ecx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmDestroy
int alarmDestroy( alarmObj *aPtr )
{
    int errCode = 1;
    if ( NULL != aPtr ) {
        if ( aPtr->usedIndex != -1 ) {
            alarmTable[ aPtr->usedIndex ] = NULL;
            free( aPtr );
            errCode = 0;
        }
    }
    return errCode;
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
je 0xf952
movslq 0x10(%rdi), %rcx
cmpq $-0x1, %rcx
je 0xf952
pushq %rax
leaq 0xb9161(%rip), %rax     # 0xc8aa0
movq $0x0, (%rax,%rcx,8)
callq 0x8040
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmDispatch
void alarmDispatch( void )
{
    alarmObj *aPtr;
    unsigned long timeNow;
    int i;
 
    timeNow = (unsigned long) time(NULL);

    for (i = 0; i<SISSM_MAXALARMS; i++) {
        aPtr = alarmTable[ i ];
        if ( aPtr != NULL ) {
            if ( aPtr->alarmTime != 0L ) {
                if ( aPtr->alarmTime <= timeNow ) {
                    aPtr->alarmTime = 0L;
                    if ( aPtr->alarmCallbackFunction != NULL ) {
                        (aPtr->alarmCallbackFunction)("alarm");
                    }
                }
            }
        }
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x82a0
movq %rax, %rbx
leaq 0xb90e0(%rip), %r12     # 0xc8aa0
leaq 0x10bed(%rip), %r14     # 0x205b4
movq (%r15,%r12), %rax
testq %rax, %rax
je 0xf9f0
movq (%rax), %rcx
decq %rcx
cmpq %rbx, %rcx
jae 0xf9f0
movq $0x0, (%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xf9f0
movq %r14, %rdi
callq *%rax
addq $0x8, %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0xf9c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pioverride.c
// Function: pokeCvar
static void _pokeCvar( void )
{
    int i;
    char cvarStr[256], cvarVal[256];
    char *w1, *w2;

    for (i=0; i<10; i++) {

        w1 = getWord( pioverrideConfig.cvar[i], 0, " " );
        w2 = getWord( pioverrideConfig.cvar[i], 1, " " );

	if (( w1 != NULL ) && ( w2 != NULL )) {
            strlcpy( cvarStr, w1, 256);
            strlcpy( cvarVal, w2, 256);

	    if ( (0 != strlen(cvarStr)) && (0 != strlen(cvarVal)) ) {
                apiGameModePropertySet( cvarStr, cvarVal );
	        logPrintf( LOG_LEVEL_INFO, "pioverride", "Setting ::%s:: to ::%s::", cvarStr, cvarVal );
	    }
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl $0x4, %r13d
leaq 0xc530(%rip), %rbx      # 0x1c156
leaq 0x100(%rsp), %r14
movq %rsp, %r15
leaq 0xb9268(%rip), %rax     # 0xc8ea0
leaq (%rax,%r13), %rbp
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xf4e1
movq %rax, %r12
movq %rbp, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xf4e1
movq %rax, %rbp
testq %r12, %r12
setne %al
testq %rbp, %rbp
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xfccd
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %r12, %rsi
callq 0xf038
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf038
cmpb $0x0, 0x100(%rsp)
je 0xfccd
cmpb $0x0, (%rsp)
je 0xfccd
movq %r14, %rdi
movq %r15, %rsi
callq 0x12e70
movl $0x2, %edi
leaq 0xda8c(%rip), %rsi      # 0x1d745
leaq 0xda90(%rip), %rdx      # 0x1d750
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1a227
addq $0x400, %r13            # imm = 0x400
cmpq $0x2804, %r13           # imm = 0x2804
jne 0xfc31
addq $0x208, %rsp            # imm = 0x208
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/pioverride.c
// Function: pioverrideInstallPlugin
int pioverrideInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pioverrideInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( pioverrideConfig.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,           pioverrideClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           pioverrideClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 pioverrideInitCB );
    eventsRegister( SISSM_EV_RESTART,              pioverrideRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            pioverrideMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           pioverrideGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             pioverrideGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          pioverrideRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            pioverrideRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   pioverrideCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             pioverridePeriodicCB );
    return 0;
}

// Assembly:
pushq %rax
callq 0xfa0c
cmpl $0x0, 0xb917e(%rip)     # 0xc8ea0
je 0xfde3
leaq -0x140(%rip), %rsi      # 0xfbef
movl $0x3, %edi
callq 0xd08c
leaq -0x14e(%rip), %rsi      # 0xfbf2
movl $0x4, %edi
callq 0xd08c
leaq -0x15c(%rip), %rsi      # 0xfbf5
movl $0x1, %edi
callq 0xd08c
leaq -0x16a(%rip), %rsi      # 0xfbf8
movl $0x2, %edi
callq 0xd08c
leaq -0x178(%rip), %rsi      # 0xfbfb
movl $0x5, %edi
callq 0xd08c
leaq -0x186(%rip), %rsi      # 0xfbfe
movl $0x6, %edi
callq 0xd08c
leaq -0xa2(%rip), %rsi       # 0xfcf3
movl $0x7, %edi
callq 0xd08c
leaq -0xb0(%rip), %rsi       # 0xfcf6
movl $0x8, %edi
callq 0xd08c
leaq -0xab(%rip), %rsi       # 0xfd0c
movl $0x9, %edi
callq 0xd08c
leaq -0xb9(%rip), %rsi       # 0xfd0f
movl $0xa, %edi
callq 0xd08c
leaq -0xc7(%rip), %rsi       # 0xfd12
movl $0xb, %edi
callq 0xd08c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: pisoloplayerInitConfig
int pisoloplayerInitConfig( void )
{
    cfsPtr cP;

    cP = cfsCreate( sissmGetConfigPath() );

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

    // how players constitute "solo"?  Typically '1' but you may override to higher player count
    //
    pisoloplayerConfig.soloPlayerThreshold = (int) cfsFetchNum( cP, "pisoloplayer.soloPlayerThreshold", 1.0 ); 

    strlcpy( pisoloplayerConfig.soloWarning, 
        cfsFetchStr( cP, "pisoloplayer.soloWarning", "Counterattack disabled for a single player" ), CFS_FETCH_MAX);
    strlcpy( pisoloplayerConfig.multiWarning, 
        cfsFetchStr( cP, "pisoloplayer.multiWarning", "Counterattack enabled for multi-players" ), CFS_FETCH_MAX);
    strlcpy( pisoloplayerConfig.defendTimer, 
        cfsFetchStr( cP, "pisoloplayer.defendTimer", "90" ), CFS_FETCH_MAX);

    cfsDestroy( cP );
    return 0;
}

// Assembly:
pushq %rbx
callq 0x8969
movq %rax, %rdi
callq 0x9004
movq %rax, %rbx
leaq 0xd969(%rip), %rsi      # 0x1d769
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0xbb892(%rip)     # 0xcb6a8
leaq 0xd965(%rip), %rsi      # 0x1d782
movsd 0xb203(%rip), %xmm0     # 0x1b028
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0xbb875(%rip)     # 0xcb6ac
leaq 0xd965(%rip), %rsi      # 0x1d7a3
leaq 0xd977(%rip), %rdx      # 0x1d7bc
movq %rbx, %rdi
callq 0x907b
leaq 0xbbc5c(%rip), %rdi     # 0xcbab0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0xd97f(%rip), %rsi      # 0x1d7e7
leaq 0xd992(%rip), %rdx      # 0x1d801
movq %rbx, %rdi
callq 0x907b
leaq 0xbb832(%rip), %rdi     # 0xcb6b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0xd997(%rip), %rsi      # 0x1d829
leaq 0xd9a9(%rip), %rdx      # 0x1d842
movq %rbx, %rdi
callq 0x907b
leaq 0xbc008(%rip), %rdi     # 0xcbeb0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
callq 0x905c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: singlePlayerNoCounter
static int _singlePlayerNoCounter( void )
{
    char *w;

    w = apiGetServerMode();
    if ((0==strcmp( w, "checkpoint" )) || (0==strcmp( w, "hardcore")) )  {
        if ( pisoloplayerConfig.soloPlayerThreshold >= apiPlayersGetCount() ) {
            apiGameModePropertySet( "DefendTimer", "3");
	    apiSay( pisoloplayerConfig.soloWarning );
            logPrintf( LOG_LEVEL_INFO, "pisoloplayer", "Counterattack disabled for a single player" );
        }
        else {
            apiGameModePropertySet( "DefendTimer", pisoloplayerConfig.defendTimer);  // default "90"
	    apiSay( pisoloplayerConfig.multiWarning );
            logPrintf( LOG_LEVEL_INFO, "pisoloplayer", "Counterattack enabled for multi-players" );
        }
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x13a76
movq %rax, %rbx
leaq 0xd0fd(%rip), %rsi      # 0x1cfdb
movq %rax, %rdi
callq 0x8220
testl %eax, %eax
je 0xff05
leaq 0xc10e(%rip), %rsi      # 0x1bfff
movq %rbx, %rdi
callq 0x8220
testl %eax, %eax
je 0xff05
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0xbb7a1(%rip), %ebx     # 0xcb6ac
callq 0x134dc
cmpl %eax, %ebx
leaq 0xbbf97(%rip), %rax     # 0xcbeb0
leaq 0xfaba(%rip), %rsi      # 0x1f9da
cmovlq %rax, %rsi
leaq 0xbb785(%rip), %rax     # 0xcb6b0
leaq 0xbbb7e(%rip), %rbx     # 0xcbab0
cmovlq %rax, %rbx
leaq 0xd8c4(%rip), %rax      # 0x1d801
leaq 0xd878(%rip), %r14      # 0x1d7bc
cmovlq %rax, %r14
leaq 0xd8f6(%rip), %rdi      # 0x1d845
callq 0x12e70
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12fba
leaq 0xd8ec(%rip), %rsi      # 0x1d851
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a227
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/pisoloplayer.c
// Function: pisoloplayerInstallPlugin
int pisoloplayerInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pisoloplayerInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( pisoloplayerConfig.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,           pisoloplayerClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           pisoloplayerClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 pisoloplayerInitCB );
    eventsRegister( SISSM_EV_RESTART,              pisoloplayerRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            pisoloplayerMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           pisoloplayerGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             pisoloplayerGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          pisoloplayerRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            pisoloplayerRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   pisoloplayerCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             pisoloplayerPeriodicCB );

    return 0;
}

// Assembly:
pushq %rax
callq 0xfde8
cmpl $0x0, 0xbb6e6(%rip)     # 0xcb6a8
je 0x10083
leaq -0x10e(%rip), %rsi      # 0xfec1
movl $0x3, %edi
callq 0xd08c
leaq -0x65(%rip), %rsi       # 0xff7b
movl $0x4, %edi
callq 0xd08c
leaq -0x6c(%rip), %rsi       # 0xff85
movl $0x1, %edi
callq 0xd08c
leaq -0x7a(%rip), %rsi       # 0xff88
movl $0x2, %edi
callq 0xd08c
leaq -0x88(%rip), %rsi       # 0xff8b
movl $0x5, %edi
callq 0xd08c
leaq -0x8f(%rip), %rsi       # 0xff95
movl $0x6, %edi
callq 0xd08c
leaq -0x96(%rip), %rsi       # 0xff9f
movl $0x7, %edi
callq 0xd08c
leaq -0xa4(%rip), %rsi       # 0xffa2
movl $0x8, %edi
callq 0xd08c
leaq -0xab(%rip), %rsi       # 0xffac
movl $0x9, %edi
callq 0xd08c
leaq -0xb9(%rip), %rsi       # 0xffaf
movl $0xa, %edi
callq 0xd08c
leaq -0xc7(%rip), %rsi       # 0xffb2
movl $0xb, %edi
callq 0xd08c
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: convertNameToHyperlink
char *_convertNameToHyperlink( char *identString )
{
    static char retStr[256];
    char playerID[80], playerName[64], *q;
    int nameIndex, formatOfID = 0;

    //    internal test injection
    //    strlcpy( identString, "fe6c0000000000000000000000000001|20000000000000000000000000000003 111.001.034.025 Random Person", 256 );
    //    strlcpy( identString,  "0123456789012345 111.001.034.025 Random Person", 256 );

    // Get the first word of identString and check if Steam or EPIC
    //
    if ( NULL != (q = getWord( identString, 0, " " ))) {
        strlcpy( playerID, q, 80 );
        formatOfID = rosterIsValidGUID( playerID );
    }

    switch( formatOfID ) {
    case 1: // Steam
        nameIndex = 34;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_STEAM, playerID, playerName );
        break;
    case 2: // EPIC
        nameIndex = 82;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_EPIC, playerID, playerName );
        break;
    case 3: // WinGDK
        nameIndex = 33;
        strlcpy( playerName, &identString[nameIndex], 64 );
        snprintf( retStr, 256, PROFILE_WINGDK, playerID, playerName );
        break;
    default:
        strlcpy( retStr, "*InternalError*", 256 );
        break;
    }

    return( retStr );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0xbe2a(%rip), %rdx      # 0x1c156
xorl %ebp, %ebp
xorl %esi, %esi
callq 0xf4e1
testq %rax, %rax
je 0x10357
movq %rsp, %r14
movl $0x50, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xf038
movq %r14, %rdi
callq 0x1403c
movl %eax, %ebp
cmpl $0x3, %ebp
je 0x103bc
cmpl $0x2, %ebp
je 0x10393
cmpl $0x1, %ebp
jne 0x103f7
addq $0x22, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf038
leaq 0xbcde6(%rip), %rdi     # 0xcd170
leaq 0xd67a(%rip), %rdx      # 0x1da0b
jmp 0x103e3
addq $0x52, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf038
leaq 0xbcdbd(%rip), %rdi     # 0xcd170
leaq 0xd699(%rip), %rdx      # 0x1da53
jmp 0x103e3
addq $0x21, %rbx
leaq 0x50(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf038
leaq 0xbcd94(%rip), %rdi     # 0xcd170
leaq 0xd6b0(%rip), %rdx      # 0x1da93
movq %rsp, %rcx
movl $0x100, %esi            # imm = 0x100
movq %r14, %r8
xorl %eax, %eax
callq 0x8190
jmp 0x10405
movups 0xd6d5(%rip), %xmm0     # 0x1dad3
movaps %xmm0, 0xbcd6b(%rip)    # 0xcd170
leaq 0xbcd64(%rip), %rax     # 0xcd170
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: htmlSafeFilter
char *_htmlSafeFilter( char *strIn )
{
    int i;
    static char strOut[ PIWEBGEN_MAXROSTER ];

    strlcpy( strOut, strIn, PIWEBGEN_MAXROSTER );

    // replace metatag or escape-sequence characters
    // with something benign (antihack)
    //
    for (i=0; i< (int) strlen( strOut ); i++) {
        switch (strOut[i]) {
            case '<':   strOut[i] = '[';  break;
            case '>':   strOut[i] = ']';  break;
            case '/':   case '\\':  strOut[i] = '|';  break;
        }
    }

    // If utf-8 encoding is NOT declared, then assume ascii.
    // replace any non-printable encodings wtih asterisks.
    // 
    if ( 0 == piwebgenConfig.utf8Encoding ) {
        for (i=0; i< (int) strlen( strOut ); i++) {
            if ( strOut[i] != '\011' )  {
                if (!isprint( (int) strOut[i] )) strOut[i] = '*';
            }
        }
    }

    return( strOut );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0xbce49(%rip), %rbx     # 0xcd270
movl $0x4000, %edx           # imm = 0x4000
movq %rbx, %rdi
callq 0xf038
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x10481
xorl %r14d, %r14d
movzbl (%r14,%rbx), %eax
cmpl $0x3d, %eax
jg 0x1045b
cmpl $0x2f, %eax
je 0x10469
movb $0x5b, %cl
cmpl $0x3c, %eax
je 0x1046b
jmp 0x1046f
cmpl $0x5c, %eax
je 0x10469
cmpl $0x3e, %eax
jne 0x1046f
movb $0x5d, %cl
jmp 0x1046b
movb $0x7c, %cl
movb %cl, (%r14,%rbx)
incq %r14
movq %rbx, %rdi
callq 0x8120
cltq
cmpq %rax, %r14
jl 0x10443
cmpl $0x0, 0xbbe2c(%rip)     # 0xcc2b4
jne 0x104d2
leaq 0xbcddf(%rip), %rbx     # 0xcd270
movq %rbx, %rdi
callq 0x8120
testl %eax, %eax
jle 0x104d2
xorl %r14d, %r14d
movsbq (%r14,%rbx), %r15
cmpq $0x9, %r15
je 0x104c0
callq 0x83e0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r15,2)
jne 0x104c0
movb $0x2a, (%r14,%rbx)
incq %r14
movq %rbx, %rdi
callq 0x8120
cltq
cmpq %rax, %r14
jl 0x104a0
leaq 0xbcd97(%rip), %rax     # 0xcd270
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: piwebgenSigtermCB
int piwebgenSigtermCB( char *strIn )
{
    FILE *fpw;

    if (NULL != (fpw = fopen( piwebgenConfig.webFileName, "wt" ))) {

	if ( 0 != piwebgenConfig.autoRefreshHeader ) 
            fprintf( fpw, "<meta http-equiv=\"refresh\" content=\"14\" /> \n" );

        fprintf( fpw, "<br><br>SISSM shut down at: &nbsp; %s\n", apiTimeGetHuman(0L) );
        fclose( fpw );
    }

    return 0;
}

// Assembly:
pushq %rbx
leaq 0xbb757(%rip), %rdi     # 0xcc2b8
leaq 0xcf84(%rip), %rsi      # 0x1daec
callq 0x8320
testq %rax, %rax
je 0x10bba
movq %rax, %rbx
cmpl $0x0, 0xbc3c8(%rip)     # 0xccf44
je 0x10b97
leaq 0xcf6a(%rip), %rdi      # 0x1daef
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x8390
xorl %edi, %edi
callq 0x12dd9
leaq 0xcf77(%rip), %rsi      # 0x1db1c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8250
movq %rbx, %rdi
callq 0x8100
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/piwebgen.c
// Function: piwebgenInstallPlugin
int piwebgenInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    piwebgenInitConfig();

    // if plugin is disabled in the .cfg file then do not activate
    //
    if ( piwebgenConfig.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,           piwebgenClientAddCB );
    eventsRegister( SISSM_EV_CLIENT_DEL,           piwebgenClientDelCB );
    eventsRegister( SISSM_EV_INIT,                 piwebgenInitCB );
    eventsRegister( SISSM_EV_RESTART,              piwebgenRestartCB );
    eventsRegister( SISSM_EV_MAPCHANGE,            piwebgenMapChangeCB );
    eventsRegister( SISSM_EV_GAME_START,           piwebgenGameStartCB );
    eventsRegister( SISSM_EV_GAME_END,             piwebgenGameEndCB );
    eventsRegister( SISSM_EV_ROUND_START,          piwebgenRoundStartCB );
    eventsRegister( SISSM_EV_ROUND_END,            piwebgenRoundEndCB );
    eventsRegister( SISSM_EV_OBJECTIVE_CAPTURED,   piwebgenCapturedCB );
    eventsRegister( SISSM_EV_PERIODIC,             piwebgenPeriodicCB );
    eventsRegister( SISSM_EV_SIGTERM,              piwebgenSigtermCB );

    return 0;
}

// Assembly:
pushq %rax
callq 0x10088
cmpl $0x0, 0xbb6e5(%rip)     # 0xcc2b0
je 0x10c9d
leaq -0x6f9(%rip), %rsi      # 0x104df
movl $0x3, %edi
callq 0xd08c
leaq -0x239(%rip), %rsi      # 0x109b0
movl $0x4, %edi
callq 0xd08c
leaq -0x234(%rip), %rsi      # 0x109c6
movl $0x1, %edi
callq 0xd08c
leaq -0x22f(%rip), %rsi      # 0x109dc
movl $0x2, %edi
callq 0xd08c
leaq -0x23d(%rip), %rsi      # 0x109df
movl $0x5, %edi
callq 0xd08c
leaq -0x238(%rip), %rsi      # 0x109f5
movl $0x6, %edi
callq 0xd08c
leaq -0x239(%rip), %rsi      # 0x10a05
movl $0x7, %edi
callq 0xd08c
leaq -0x247(%rip), %rsi      # 0x10a08
movl $0x8, %edi
callq 0xd08c
leaq -0x255(%rip), %rsi      # 0x10a0b
movl $0x9, %edi
callq 0xd08c
leaq -0x263(%rip), %rsi      # 0x10a0e
movl $0xa, %edi
callq 0xd08c
leaq -0x271(%rip), %rsi      # 0x10a11
movl $0xb, %edi
callq 0xd08c
leaq -0x13a(%rip), %rsi      # 0x10b59
movl $0xf, %edi
callq 0xd08c
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/api.c
// Function: apiRemoveCodes
void apiRemoveCodes( char *apiSayString )
{
    int j = 0;
    char *w;
    char removeWord[ API_LINE_STRING_MAX ];

    if ( 0 != strlen( removeCodes ) ) {
        while ( 1 == 1 ) {
            w = getWord( removeCodes, j++, " " );
            if ( w == NULL ) break;
            if ( 0 == strlen( w ) ) break;
            strlcpy( removeWord, w, API_LINE_STRING_MAX );
            strRemoveInPlace( apiSayString, removeWord );
        };
    };
    return;
}

// Assembly:
cmpb $0x0, 0xc05d5(%rip)     # 0xd1280
je 0x10d41
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0xc05b4(%rip), %rdi     # 0xd1280
leaq 0xb483(%rip), %rdx      # 0x1c156
xorl %esi, %esi
callq 0xf4e1
testq %rax, %rax
je 0x10d30
movl $0x1, %r13d
movq %rsp, %r14
leaq 0xc0591(%rip), %r15     # 0xd1280
leaq 0xb460(%rip), %r12      # 0x1c156
cmpb $0x0, (%rax)
je 0x10d30
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %rax, %rsi
callq 0xf038
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf680
leal 0x1(%r13), %ebp
movq %r15, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0xf4e1
movl %ebp, %r13d
testq %rax, %rax
jne 0x10cf6
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/api.c
// Function: apiWordListRead
int apiWordListRead( char *listFile, wordList_t wordList )
{
    int i;
    char tmpLine[1024];
    FILE *fpr;

    for (i=0; i<WORDLISTMAXELEM; i++) strclr( wordList[i] );

    i = -1;
    if (NULL != (fpr = fopen( listFile, "rt" ))) {
        i = 0;
        while (!feof( fpr )) { 
            if (NULL != fgets( tmpLine, 1024, fpr )) {
                tmpLine[ strlen( tmpLine ) - 1] = 0;
                strTrimInPlace( tmpLine );
                if ( 0 != strlen( tmpLine ) ) {
                    // strToLowerInPlace( tmpLine ); 
                    strlcpy( wordList[ i ], tmpLine, WORDLISTMAXSTRSZ );
                    if ( (++i) > WORDLISTMAXELEM) break;
                }
            }
        }
        fclose( fpr );
    }
    return( i );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
callq 0xf4dd
addq $0x20, %r15
cmpq $0x8000, %r15           # imm = 0x8000
jne 0x10d5a
leaq 0xb11c(%rip), %rsi      # 0x1be93
movq %r14, %rdi
callq 0x8320
testq %rax, %rax
je 0x10e0d
movq %rax, %r14
movq %rax, %rdi
callq 0x8270
xorl %ebp, %ebp
testl %eax, %eax
jne 0x10e03
xorl %ebp, %ebp
movq %rsp, %r15
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x8200
testq %rax, %rax
je 0x10df7
movq %r15, %rdi
callq 0x8120
movb $0x0, -0x1(%rax,%r15)
movq %r15, %rdi
callq 0xf5e3
cmpb $0x0, (%rsp)
je 0x10df7
movslq %ebp, %r12
movq %r12, %rdi
shlq $0x5, %rdi
addq %rbx, %rdi
movl $0x20, %edx
movq %r15, %rsi
callq 0xf038
leal 0x1(%r12), %ebp
cmpl $0x3ff, %r12d           # imm = 0x3FF
jg 0x10e03
movq %r14, %rdi
callq 0x8270
testl %eax, %eax
je 0x10d9e
movq %r14, %rdi
callq 0x8100
jmp 0x10e12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/api.c
// Function: apiWordListCheck
int apiWordListCheck( char *stringTested, wordList_t wordList )
{
    int i;
    int isMatch = 0;

    for (i=0; i<WORDLISTMAXELEM; i++) {

        if ( wordList[i][0] == 0 ) break;
        if ( NULL != strcasestr( stringTested, wordList[i] )) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpb $0x0, (%r14,%r12)
je 0x10e63
leaq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x8350
testq %rax, %rax
jne 0x10e5e
addq $0x20, %r12
cmpq $0x8000, %r12           # imm = 0x8000
jne 0x10e37
jmp 0x10e63
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/api.c
// Function: apiWordListCheckExact
int apiWordListCheckExact( char *stringTested, wordList_t wordList )
{
    int i;
    int isMatch = 0;

    for (i=0; i<WORDLISTMAXELEM; i++) {

        if ( wordList[i][0] == 0 ) break;
        if ( 0 == strncmp( stringTested, wordList[i], WORDLISTMAXSTRSZ ) ) {
            isMatch = 1;
            break;
        }
    }
    return( isMatch );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpb $0x0, (%r14,%r12)
je 0x10eb4
leaq (%r14,%r12), %rsi
movl $0x20, %edx
movq %r15, %rdi
callq 0x8080
testl %eax, %eax
je 0x10eaf
addq $0x20, %r12
cmpq $0x8000, %r12           # imm = 0x8000
jne 0x10e84
jmp 0x10eb4
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListAdd
int apiIdListAdd( char *connectID, idList_t idList ) 
{
    int i, j;
 
    for ( j = -1, i = 0; i<IDLISTMAXELEM; i++ ) {
        if ( 0 == strlen( idList[i] )) {   // found an empty slot
            j = i;
            break;
        }
    }
    if (( j != -1 ) && ( connectID != NULL ))
        strlcpy( idList[j], connectID, IDLISTMAXSTRSZ );

    return j;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
xorl %ebx, %ebx
movl $0x100, %ecx            # imm = 0x100
movq %rsi, %rdx
cmpb $0x0, (%rdx)
je 0x10ee5
incq %rbx
addq %rcx, %rdx
cmpq %rcx, %rbx
jne 0x10ed0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x10f0f
movslq %ebx, %rcx
shlq $0x8, %rcx
addq %rcx, %rsi
movl $0x100, %edx            # imm = 0x100
movq %rsi, %rdi
movq %rax, %rsi
callq 0xf038
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/schroeder-lvb[P]sissm/src/api.c
// Function: apiIdListGet
char *apiIdListGet( idList_t idList, int index )
{
    static char retStr[IDLISTMAXSTRSZ];
     
    strclr( retStr );
    if ( index < IDLISTMAXELEM ) {
        strlcpy( retStr, idList[ index ], IDLISTMAXSTRSZ );
    }
    return retStr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc0431(%rip), %rdi     # 0xd1380
callq 0xf4dd
cmpl $0xff, %ebp
jg 0x10f7a
movslq %ebp, %rax
shlq $0x8, %rax
addq %rax, %rbx
leaq 0xc0413(%rip), %rdi     # 0xd1380
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rsi
callq 0xf038
leaq 0xc03ff(%rip), %rax     # 0xd1380
addq $0x8, %rsp
popq %rbx
popq %rbp
retq