LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterRoundStartCB
int pirebooterRoundStartCB( char *strIn )
{
    pirebooterConfig.timeFirstIdle  = 0L;
    pirebooterConfig.timeLastProgress = apiTimeGet();

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, 0x74281(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x7427d(%rip)     # 0x838c0
movq 0x74266(%rip), %rax     # 0x838b0
addq 0x73e3f(%rip), %rax     # 0x83490
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xf67b
leaq 0x73e13(%rip), %rdi     # 0x83480
addq $0x448, %rdi            # imm = 0x448
movb $0x0, %al
callq 0x17af0
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/pirebooter.c
// Function: pirebooterRoundEndCB
int pirebooterRoundEndCB( char *strIn )
{
    pirebooterConfig.timeLastProgress = apiTimeGet();
    pirebooterConfig.timeFirstIdle  = 0L;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x150c0
movq %rax, 0x74218(%rip)     # 0x838c0
movq $0x0, 0x74205(%rip) # 0x838b8
cmpq $0x0, 0x741ed(%rip)     # 0x838a8
je 0xf72b
movq 0x741ec(%rip), %rax     # 0x838b0
addq 0x73dc5(%rip), %rax     # 0x83490
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xf729
callq 0x150c0
movq %rax, 0x741c4(%rip)     # 0x838b0
movq $0x0, 0x741c1(%rip) # 0x838b8
callq 0x150c0
movq %rax, 0x741bd(%rip)     # 0x838c0
movl $0x2, %edi
leaq 0x1558a(%rip), %rsi     # 0x24c99
leaq 0x155bb(%rip), %rdx     # 0x24cd1
movb $0x0, %al
callq 0x21bf0
leaq 0x15599(%rip), %rdi     # 0x24cbd
callq 0x17510
jmp 0xf72b
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/pirebooter.c
// Function: pirebooterCapturedCB
int pirebooterCapturedCB( char *strIn )
{
    static unsigned long lastTime = 0L;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x150c0
movq %rax, 0x74168(%rip)     # 0x838c0
movq $0x0, 0x74155(%rip) # 0x838b8
movq 0x74146(%rip), %rax     # 0x838b0
addq 0x73d1f(%rip), %rax     # 0x83490
movq %rax, -0x10(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xf7c9
movq 0x7493b(%rip), %rax     # 0x840c8
addq $0xa, %rax
movq %rax, -0x18(%rbp)
callq 0x150c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0xf7c7
callq 0x150c0
movq %rax, 0x74916(%rip)     # 0x840c8
leaq 0x73cc7(%rip), %rdi     # 0x83480
addq $0x448, %rdi            # imm = 0x448
movb $0x0, %al
callq 0x17af0
jmp 0xf7c9
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pirebooter.c
// Function: pirebooterActivityCB
int pirebooterActivityCB( char *strIn )
{
    if ( NULL != strstr( strIn, " killed " ) ) {
        if ( NULL != strstr( strIn, " with " ) ) {
            pirebooterConfig.timeLastProgress = apiTimeGet();
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17223(%rip), %rsi     # 0x26a1a
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xf82e
movq -0x8(%rbp), %rdi
leaq 0x1722d(%rip), %rsi     # 0x26a3e
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xf82c
callq 0x150c0
movq %rax, 0x74094(%rip)     # 0x838c0
jmp 0xf82e
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/pirebooter.c
// Function: pirebooterInstallPlugin
int pirebooterInstallPlugin( void )
{
    // Read the plugin-specific variables from the .cfg file 
    // 
    pirebooterInitConfig();

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

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xf1e0
cmpl $0x0, 0x7383c(%rip)     # 0x83480
jne 0xfc52
movl $0x0, -0x4(%rbp)
jmp 0xfd36
movl $0x3, %edi
leaq -0x84e(%rip), %rsi      # 0xf410
callq 0xee50
movl $0x4, %edi
leaq -0x83f(%rip), %rsi      # 0xf430
callq 0xee50
movl $0x1, %edi
leaq -0x830(%rip), %rsi      # 0xf450
callq 0xee50
movl $0x2, %edi
leaq -0x801(%rip), %rsi      # 0xf490
callq 0xee50
movl $0x5, %edi
leaq -0x802(%rip), %rsi      # 0xf4a0
callq 0xee50
movl $0x6, %edi
leaq -0x7e3(%rip), %rsi      # 0xf4d0
callq 0xee50
movl $0x7, %edi
leaq -0x754(%rip), %rsi      # 0xf570
callq 0xee50
movl $0x8, %edi
leaq -0x6b5(%rip), %rsi      # 0xf620
callq 0xee50
movl $0x9, %edi
leaq -0x656(%rip), %rsi      # 0xf690
callq 0xee50
movl $0xa, %edi
leaq -0x5b7(%rip), %rsi      # 0xf740
callq 0xee50
movl $0xb, %edi
leaq -0x498(%rip), %rsi      # 0xf870
callq 0xee50
movl $0xe, %edi
leaq -0x4d9(%rip), %rsi      # 0xf840
callq 0xee50
movl $0x1c, %edi
leaq -0x54a(%rip), %rsi      # 0xf7e0
callq 0xee50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pidynbots.c
// Function: pidynbotsPeriodicCB
int pidynbotsPeriodicCB( char *strIn )  
{
    int sigBotScaleChanged;

    // Signal Handler FROM picladmin
    // 
    //
    sigBotScaleChanged = p2pGetL( "pidynbots.p2p.sigBotScaled", 0L ); 
    if ( sigBotScaleChanged ) {

        // Clear the signal
        p2pSetL( "pidynbots.p2p.sigBotScaled", 0L ); 
        // Force an update
        _computeBotParams( 0 );
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x13a08(%rip), %rdi     # 0x23a8b
xorl %eax, %eax
movl %eax, %esi
callq 0x1eda0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x100ac
leaq 0x139ef(%rip), %rdi     # 0x23a8b
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
xorl %edi, %edi
callq 0x100c0
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/pidynbots.c
// Function: pidynbotsRoundStartCB
int pidynbotsRoundStartCB( char *strIn )
{
    logPrintf( LOG_LEVEL_INFO, "pidynbots", "Round Start Event ::%s::", strIn );

    // Compute offset to botcounts per different game mode
    // if parse error is detected, run wtih '0' for now
    // 
    if ( _modeBotCountOffset( &pidynMinimumOffset, &pidynMmaximumOffset )  ) {
        pidynMinimumOffset = 0;
        pidynMmaximumOffset = 0;
    } 

    _computeBotParams( 1 );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x146ad(%rip), %rsi     # 0x24f79
leaq 0x146ef(%rip), %rdx     # 0x24fc2
movb $0x0, %al
callq 0x21bf0
leaq 0x737ff(%rip), %rdi     # 0x840e0
leaq 0x737fc(%rip), %rsi     # 0x840e4
callq 0x10920
cmpl $0x0, %eax
je 0x10906
movl $0x0, 0x737e4(%rip)     # 0x840e0
movl $0x0, 0x737de(%rip)     # 0x840e4
movl $0x1, %edi
callq 0x100c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pidynbots.c
// Function: botScale
static unsigned int _botScale( unsigned int currHuman, 
    unsigned int maxBots, unsigned int minBots,
    unsigned int maxHuman, unsigned int minHuman )
{
    int errCode = 0;
    unsigned int _currHuman = currHuman;
    double slope;
    unsigned int currBots = 1;

    // check for invalid entry by the operator
    //
    if (0 == errCode)
        if ( maxBots < minBots )    errCode = 1;    // check neg slope
    if (0 == errCode)
        if ( maxHuman <= minHuman ) errCode = 1;    // check neg slope & divide-by-zero

    if (0 == errCode) {

        // clip the human counts to given limits
        //
        if ( _currHuman < minHuman ) _currHuman = minHuman;
        if ( _currHuman > maxHuman ) _currHuman = maxHuman;

        // compute the 2-point linear formula
        // y = f(x) = ((y1-y0) / (x1-x0)) * (x-x0) + y1;
        //
        slope = (( (double) maxBots - (double) minBots ) / ( (double) maxHuman - (double) minHuman ));
        currBots = (unsigned int ) (slope * ( _currHuman - minHuman ) + minBots);
    }

    // on error, this routine returns 'safe' bot value of '1'
    //
    return( currBots );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x2c(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0x10e60
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x10e5e
movl $0x1, -0x18(%rbp)
jmp 0x10e60
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0x10e78
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x10e76
movl $0x1, -0x18(%rbp)
jmp 0x10e78
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0x10ef6
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x10e8d
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jbe 0x10e9b
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm0
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
movl -0x10(%rbp), %eax
cvtsi2sd %rax, %xmm1
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm2
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl %ecx, %eax
cvtsi2sd %rax, %xmm2
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pidynbots.c
// Function: inRespawnCoopMode
static int _inRespawnCoopMode( int refresh )
{
    int inRespawnMode = 0;
    char *s1;
    static int lastMode = -1;

    if ( (lastMode == -1) || refresh ) {
        s1 = apiGameModePropertyGet( "bbots" );
        if ( NULL != strstr( s1, "True" ) ) inRespawnMode = 1;
        lastMode = inRespawnMode;
    }
    inRespawnMode = lastMode;

    return( inRespawnMode );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $-0x1, 0x20b97(%rip)    # 0x31ab0
je 0x10f21
cmpl $0x0, -0x4(%rbp)
je 0x10f5b
leaq 0x141df(%rip), %rdi     # 0x25107
callq 0x17720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x141d1(%rip), %rsi     # 0x2510d
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x10f52
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, 0x20b55(%rip)     # 0x31ab0
movl 0x20b4f(%rip), %eax     # 0x31ab0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0xb9f86(%rip), %rdi     # 0xcb750
callq 0x122b0
movl 0xb955f(%rip), %eax     # 0xcad34
cmpl 0x9b14d(%rip), %eax     # 0xac928
jle 0x11852
leaq 0xb9f6c(%rip), %rdi     # 0xcb750
leaq 0xb9555(%rip), %rsi     # 0xcad40
movl $0x50, %edx
callq 0x11bc0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xb952f(%rip), %eax     # 0xcad34
jge 0x11850
movslq -0xc(%rbp), %rax
leaq 0xb952e(%rip), %rdi     # 0xcad40
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0xb9f30(%rip), %rsi     # 0xcb750
callq 0x8200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x11836
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x9b0e9(%rip), %eax     # 0xac928
jle 0x11843
jmp 0x11850
jmp 0x11845
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x117fc
jmp 0x11852
movl -0x10(%rbp), %eax
cmpl 0x9b0cd(%rip), %eax     # 0xac928
jle 0x11895
leaq 0xb9eec(%rip), %rdi     # 0xcb750
leaq 0x9b0b5(%rip), %rsi     # 0xac920
addq $0x10, %rsi
callq 0x17ee0
movl $0x1, %edi
leaq 0x13a12(%rip), %rsi     # 0x25292
leaq 0x13b9c(%rip), %rdx     # 0x25423
leaq 0xb9ec2(%rip), %rcx     # 0xcb750
movb $0x0, %al
callq 0x21bf0
movl $0x0, 0xb9495(%rip)     # 0xcad34
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x4f, 0xb9dab(%rip)    # 0xcb740
movl $0x4d, 0xb9da5(%rip)    # 0xcb744
movl $0x0, 0xb9df7(%rip)     # 0xcb7a0
movl $0x0, 0xb9381(%rip)     # 0xcad34
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0x119e2
movslq -0x4(%rbp), %rax
leaq 0xb9375(%rip), %rdi     # 0xcad40
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x122b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x119ba
movl $0x1, 0x9af34(%rip)     # 0xac920
movl $0x3, 0x9af32(%rip)     # 0xac928
movl $0x3, 0x9af2c(%rip)     # 0xac92c
leaq 0x9af29(%rip), %rdi     # 0xac930
leaq 0x13a4e(%rip), %rsi     # 0x2545c
callq 0x8070
movl $0x0, -0x4(%rbp)
cmpl $0x3e8, -0x4(%rbp)      # imm = 0x3E8
jge 0x11a6c
leaq -0x110(%rbp), %rdi
leaq 0x13a30(%rip), %rsi     # 0x25461
callq 0x8070
leaq -0x110(%rbp), %rdi
callq 0x115f0
leaq -0x110(%rbp), %rdi
leaq 0x13a6f(%rip), %rsi     # 0x254bf
callq 0x8070
leaq -0x110(%rbp), %rdi
callq 0x115f0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x11a1a
leaq -0x110(%rbp), %rdi
callq 0x117b0
leaq -0x110(%rbp), %rdi
callq 0x117b0
leaq -0x110(%rbp), %rdi
callq 0x117b0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
je 0x11af6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x11aff
jmp 0x11b0d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11acc
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x11b50
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x11bb3
jmp 0x11b52
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11b96
cmpq $0x1, -0x38(%rbp)
je 0x11b88
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11b52
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x122b0
cmpl $-0x1, -0x4(%rbp)
je 0x11e06
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1024(%rbp)
leaq -0x1020(%rbp), %rdi
movl -0x1024(%rbp), %ecx
movl $0xfff, %esi            # imm = 0xFFF
leaq 0x13852(%rip), %rdx     # 0x25613
movb $0x0, %al
callq 0x8180
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x80d0
movq %rax, -0x1030(%rbp)
cmpq $0x0, -0x1030(%rbp)
jle 0x11e04
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x1030(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x11e06
movl -0x14(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/ftrack.c
// Function: ftrackClose
void ftrackClose( ftrackObj *fPtr )
{

    if ( fPtr != NULL ) {
#ifdef _WIN32
        if (fPtr->fpr != NULL) {
            fclose( fPtr->fpr );
            fPtr->fpr = NULL;
        }
#else
        if (fPtr->fpr != -1) {
            close( fPtr->fpr );
            fPtr->fpr = -1;
        }
#endif
        free( fPtr );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1203a
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x12031
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x8030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movl $0x4, %edi
leaq 0x1342f(%rip), %rsi     # 0x25586
movl $0x1, %edx
callq 0x21bb0
leaq 0x1342c(%rip), %rdi     # 0x25594
callq 0x11c90
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12190
leaq 0x13479(%rip), %rdi     # 0x255f8
movb $0x0, %al
callq 0x8170
movl $0x1, %edi
callq 0x8360
jmp 0x12192
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x12040
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x121d5
movq -0x8(%rbp), %rdi
callq 0x11e20
movq %rax, %rsi
leaq -0x410(%rbp), %rdx
leaq 0x13439(%rip), %rdi     # 0x25605
movb $0x0, %al
callq 0x8170
jmp 0x121e8
movq -0x8(%rbp), %rdi
callq 0x11e60
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x83c0
jmp 0x12192
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x1221b
leaq 0xb959f(%rip), %rdi     # 0xcb7b0
callq 0x122b0
jmp 0x122a1
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xe10, %ecx            # imm = 0xE10
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
imulq $0xe10, -0x20(%rbp), %rcx # imm = 0xE10
subq %rcx, %rax
movl $0x3c, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
imulq $0xe10, -0x20(%rbp), %rcx # imm = 0xE10
imulq $0x3c, -0x28(%rbp), %rdx
addq %rdx, %rcx
subq %rcx, %rax
movl $0x3c, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0xb9522(%rip), %rdi     # 0xcb7b0
movl $0x100, %esi            # imm = 0x100
leaq 0x1338a(%rip), %rdx     # 0x25624
movb $0x0, %al
callq 0x8180
leaq 0xb9508(%rip), %rax     # 0xcb7b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x0, 0xbd5b6(%rip)     # 0xcf8af
movq -0x8(%rbp), %rsi
leaq 0xb95ac(%rip), %rdi     # 0xcb8b0
movl $0x3ffe, %edx           # imm = 0x3FFE
callq 0x11bc0
movq -0x18(%rbp), %rsi
leaq 0xb9597(%rip), %rdi     # 0xcb8b0
callq 0x8330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1234e
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl -0xc(%rbp), %eax
jne 0x1233b
jmp 0x1234e
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x8330
movq %rax, -0x20(%rbp)
jmp 0x12322
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xbd52b(%rip), %rdi     # 0xcf8b0
movl $0x1000, %edx           # imm = 0x1000
callq 0x11bc0
cmpl $0x0, -0x14(%rbp)
je 0x123ed
movl $0x0, -0x1c(%rbp)
cmpl $0x1000, -0x1c(%rbp)    # imm = 0x1000
jge 0x123e6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x8290
movb %al, %dl
movslq -0x1c(%rbp), %rcx
leaq 0xbd4ed(%rip), %rax     # 0xcf8b0
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x123d9
jmp 0x123e6
jmp 0x123db
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1239c
movb $0x0, 0xbe4c2(%rip)     # 0xd08af
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x1243e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xbd495(%rip), %rdi     # 0xcf8b0
callq 0x8390
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x12433
movl $0x1, -0x18(%rbp)
jmp 0x1243e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x123f4
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8110
movl %eax, -0x14(%rbp)
callq 0x83b0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x124b0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x12470
jmp 0x124b2
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x124e7
callq 0x83b0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x124f0
jmp 0x12507
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x124b2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x82f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/util.c
// Function: strClean
void strClean( char *strIn )
{
    int w = (int) strlen( strIn );
    
    if ( w > 0 ) {
        if ( strIn[ w-1 ] == 0x0d ) strIn[ w-1 ] = 0;
        else if ( strIn[ w-1 ] == 0x0a ) strIn[ w-1 ] = 0;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x125a2
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x12577
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x125a0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1259e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x125a0
jmp 0x125a2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbe1fd(%rip), %rdi     # 0xd08b0
leaq 0x10bd0(%rip), %rsi     # 0x2328a
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x12f65(%rip), %rsi     # 0x25634
leaq -0xc(%rbp), %rdx
leaq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %r8
leaq -0x18(%rbp), %r9
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x4, %eax
cmpl %ecx, %eax
jne 0x12742
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x12740
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x12740
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jae 0x12740
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x12740
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl -0x14(%rbp), %r9d
movl -0x18(%rbp), %eax
leaq 0xbe186(%rip), %rdi     # 0xd08b0
movl $0x100, %esi            # imm = 0x100
leaq 0x12f0a(%rip), %rdx     # 0x25640
movl %eax, (%rsp)
movb $0x0, %al
callq 0x8180
jmp 0x12742
leaq 0xbe167(%rip), %rax     # 0xd08b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12ee6(%rip), %rsi     # 0x25654
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x127b3
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
movq %rdx, %rsi
callq 0x80a0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x127aa
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x80f0
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
cmpq $0x1, %rax
jbe 0x12851
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movl -0x10(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1284f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x12842
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x12842
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x7, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x7, (%rax,%rcx)
jmp 0x12844
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x127e2
jmp 0x12851
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11611(%rip), %rsi     # 0x23e93
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x128ea
movq -0x20(%rbp), %rdx
leaq 0xbe110(%rip), %rdi     # 0xd09b0
movl $0x100, %esi            # imm = 0x100
callq 0x81e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x128e1
movq -0x10(%rbp), %rdx
leaq 0xbe0f1(%rip), %rdi     # 0xd09b0
leaq 0x11809(%rip), %rsi     # 0x240cf
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x128df
movl $0x0, -0x14(%rbp)
jmp 0x128e1
movq -0x20(%rbp), %rdi
callq 0x80f0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmInit
void alarmInit( void )
{
    int i;
    for (i=0; i<SISSM_MAXALARMS; i++) {
        alarmTable[ i ] = NULL;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x12932
movslq -0x4(%rbp), %rcx
leaq 0xbe191(%rip), %rax     # 0xd0ab0
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1290b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x81f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x129d5
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x129d3
movslq -0x14(%rbp), %rcx
leaq 0xbe110(%rip), %rax     # 0xd0ab0
cmpq $0x0, (%rax,%rcx,8)
jne 0x129c6
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0xbe0fa(%rip), %rax     # 0xd0ab0
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x129d3
jmp 0x129c8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1298c
jmp 0x129d5
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x12a2e
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
je 0x12a2c
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0xbe09c(%rip), %rax     # 0xd0ab0
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
callq 0x8030
movl $0x0, -0xc(%rbp)
jmp 0x12a2e
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/alarm.c
// Function: alarmStatus
long int alarmStatus( alarmObj *aPtr )
{
    unsigned long retValue = 0L;
    unsigned long timeNow;

    timeNow = (unsigned long) time(NULL);
    if ( aPtr->alarmTime > timeNow ) retValue = aPtr->alarmTime - timeNow;
    return retValue; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x8280
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x12add
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x8280
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x12b7d
movslq -0x14(%rbp), %rcx
leaq 0xbdf90(%rip), %rax     # 0xd0ab0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12b70
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12b6e
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x12b6c
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12b6a
movq -0x8(%rbp), %rax
leaq 0x15a35(%rip), %rdi     # 0x2859c
callq *0x8(%rax)
jmp 0x12b6c
jmp 0x12b6e
jmp 0x12b70
jmp 0x12b72
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12b0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jge 0x12fba
movslq -0x4(%rbp), %rax
leaq 0xbe009(%rip), %rdi     # 0xd0eb0
addq $0x4, %rdi
shlq $0xa, %rax
addq %rax, %rdi
xorl %esi, %esi
leaq 0x1129d(%rip), %rdx     # 0x24158
callq 0x122d0
movq %rax, -0x218(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xbdfde(%rip), %rdi     # 0xd0eb0
addq $0x4, %rdi
shlq $0xa, %rax
addq %rax, %rdi
movl $0x1, %esi
leaq 0x1126f(%rip), %rdx     # 0x24158
callq 0x122d0
movq %rax, -0x220(%rbp)
cmpq $0x0, -0x218(%rbp)
je 0x12faa
cmpq $0x0, -0x220(%rbp)
je 0x12faa
leaq -0x110(%rbp), %rdi
movq -0x218(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x110(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x12fa8
leaq -0x210(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x12fa8
leaq -0x110(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x176f0
leaq -0x110(%rbp), %rcx
leaq -0x210(%rbp), %r8
movl $0x2, %edi
leaq 0x127ac(%rip), %rsi     # 0x25746
leaq 0x127b0(%rip), %rdx     # 0x25751
movb $0x0, %al
callq 0x21bf0
jmp 0x12faa
jmp 0x12fac
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x12e92
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x12b90
cmpl $0x0, 0xbde5c(%rip)     # 0xd0eb0
jne 0x13062
movl $0x0, -0x4(%rbp)
jmp 0x13124
movl $0x3, %edi
leaq -0x25e(%rip), %rsi      # 0x12e10
callq 0xee50
movl $0x4, %edi
leaq -0x25f(%rip), %rsi      # 0x12e20
callq 0xee50
movl $0x1, %edi
leaq -0x260(%rip), %rsi      # 0x12e30
callq 0xee50
movl $0x2, %edi
leaq -0x261(%rip), %rsi      # 0x12e40
callq 0xee50
movl $0x5, %edi
leaq -0x262(%rip), %rsi      # 0x12e50
callq 0xee50
movl $0x6, %edi
leaq -0x263(%rip), %rsi      # 0x12e60
callq 0xee50
movl $0x7, %edi
leaq -0x104(%rip), %rsi      # 0x12fd0
callq 0xee50
movl $0x8, %edi
leaq -0x105(%rip), %rsi      # 0x12fe0
callq 0xee50
movl $0x9, %edi
leaq -0xe6(%rip), %rsi       # 0x13010
callq 0xee50
movl $0xa, %edi
leaq -0xe7(%rip), %rsi       # 0x13020
callq 0xee50
movl $0xb, %edi
leaq -0xe8(%rip), %rsi       # 0x13030
callq 0xee50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)