// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/piantirush.c
// Function: piantirushInitConfig
int piantirushInitConfig( void )
{
    cfsPtr cP;

    cP = cfsCreate( sissmGetConfigPath() );

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

    piantirushConfig.nPlayerExemption = (int)           
        cfsFetchNum( cP, "piantirush.nPlayerExemption",  2 ); 
    piantirushConfig.nPlayerLockThreshold  = (int)      
        cfsFetchNum( cP, "piantirush.nPlayerLockThreshold",  6 ); 

    strlcpy( piantirushConfig.fastPrompt,               
        cfsFetchStr( cP, "piantirush.fastPrompt", "Standard capture rate unlocked" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.fastObjectiveCaptureTime, 
        cfsFetchStr( cP, "piantirush.fastObjectiveCaptureTime", "30" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.fastObjectiveSpeedup,     
        cfsFetchStr( cP, "piantirush.fastObjectiveSpeedup", "0.25" ), CFS_FETCH_MAX);

    piantirushConfig.slowIntervalSec = (int)            
        cfsFetchNum( cP, "piantirush.slowIntervalSec", 135 ); 
    strlcpy( piantirushConfig.slowPrompt,               
        cfsFetchStr( cP, "piantirush.slowPrompt", "SLOW DOWN! Objective Rushers will be banned." ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.slowObjectiveCaptureTime, 
        cfsFetchStr( cP, "piantirush.slowObjectiveCaptureTime", "90" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.slowObjectiveSpeedup,     
        cfsFetchStr( cP, "piantirush.slowObjectiveSpeedup", "0.00" ), CFS_FETCH_MAX);

    piantirushConfig.lockIntervalSec = (int)            
        cfsFetchNum( cP, "piantirush.lockIntervalSec", 210 ); 
    strlcpy( piantirushConfig.lockPrompt,               
        cfsFetchStr( cP, "piantirush.lockPrompt", "Capture is locked until notified" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.lockObjectiveCaptureTime, 
        cfsFetchStr( cP, "piantirush.lockObjectiveCaptureTime", "210" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.lockObjectiveSpeedup,     
        cfsFetchStr( cP, "piantirush.lockObjectiveSpeedup", "0.00" ), CFS_FETCH_MAX);

    strlcpy( piantirushConfig.warnRusherCapturable,     // "*Rule: Ask before entering capture zone"
        cfsFetchStr( cP, "piantirush.warnRusherCapturable", "" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.warnRusherDestructible,   // "*Rule: Ask before exploding the cache" 
        cfsFetchStr( cP, "piantirush.warnRusherDestructible", "" ), CFS_FETCH_MAX);
    piantirushConfig.warnRusherDelaySec = (int)            
        cfsFetchNum( cP, "piantirush.warnRusherDelaySec", 20 );

    piantirushConfig.autoKickEarlyDestruction = (int)
        cfsFetchNum( cP, "piantirush.autoKickEarlyDestruction", 0 );
    piantirushConfig.destroySpeedup = (int)
        cfsFetchNum( cP, "piantirush.destroySpeedup", 90 );

    strlcpy( piantirushConfig.destroyOkPrompt,     // prompt authorizing players destroy the cache
        cfsFetchStr( cP, "piantirush.destroyOkPrompt", "Cache destruction AUTHORIZED if team concurs" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.destroyDenyPrompt,     // prompt denying players destroy the cache
        cfsFetchStr( cP, "piantirush.destroyDenyPrompt", "Early destruct DENIED at this time." ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.destroyHoldPrompt,     // prompt ordering players to halt destruction of cache
        cfsFetchStr( cP, "piantirush.destroyHoldPrompt", "*Cache destruct UNAUTHORIZED - type '22' then '11'" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.earlyDestroyKickMessage,     // 'reason' displayed to kicked player 
        cfsFetchStr( cP, "piantirush.earlyDestroyKickMessage", "Auto-kicked for Unauthorized early cache destruction" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.earlyDestroyPlayerRequest,     // command typed by players to request early destroy
        cfsFetchStr( cP, "piantirush.earlyDestroyPlayerRequest", "aa ff 11 22 ask req" ), CFS_FETCH_MAX);

    piantirushConfig.earlyDestroyTolerance = (int)          // do not kick players if # seconds prior to timer expiry
        cfsFetchNum( cP, "piantirush.earlyDestroyTolerance", 10 );

    piantirushConfig.earlyBreachShow     = (int) cfsFetchNum( cP, "piantirush.earlyBreachShow", 0 );
    piantirushConfig.autoKickEarlyBreach = (int) cfsFetchNum( cP, "piantirush.autoKickEarlyBreach", 0 );
    piantirushConfig.earlyBreachSpeedup  = (int) cfsFetchNum( cP, "piantirush.earlyBreachSpeedup", 90 );
    piantirushConfig.earlyBreachMaxTime  = (int) cfsFetchNum( cP, "piantirush.earlyBreachMaxTime", 12 );
    piantirushConfig.earlyBreachMaxTaps  = (int) cfsFetchNum( cP, "piantirush.earlyBreachMaxTaps", 7 );

    strlcpy( piantirushConfig.earlyBreachPlayerRequest,
        cfsFetchStr( cP, "piantirush.earlyBreachPlayerRequest", "aa ff 00 11 ask req"), CFS_FETCH_MAX);     
    strlcpy( piantirushConfig.earlyBreachTapsKickMessage,
        cfsFetchStr( cP, "piantirush.earlyBreachTapsKickMessage", "Auto-kicked for excessive number of nuisance objective taps"), CFS_FETCH_MAX);   
    strlcpy( piantirushConfig.earlyBreachTimeKickMessage,
        cfsFetchStr( cP, "piantirush.earlyBreachTimeKickedMessage", "Auto-kicked for early territorial zone breach"), CFS_FETCH_MAX);   

    strlcpy( piantirushConfig.breachOkPrompt,     // prompt authorizing players ok to breach
        cfsFetchStr( cP, "piantirush.breachOkPrompt", "Breach is AUTHORIZED if team concurs" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.breachDenyPrompt,     // prompt denying players breach
        cfsFetchStr( cP, "piantirush.breachDenyPrompt", "Breach is DENIED at this time." ), CFS_FETCH_MAX);

    strlcpy( piantirushConfig.earlyBreachWarn, cfsFetchStr( cP, "piantirush.earlyBreachWarn", "premature breach warning"), CFS_FETCH_MAX);   
    strlcpy( piantirushConfig.earlyBreachExit, cfsFetchStr( cP, "piantirush.earlyBreachExit", "has left the objective"), CFS_FETCH_MAX);   

    piantirushConfig.autoKickExemptLMS = (int) cfsFetchNum( cP, "piantirush.autoKickExemptLMS", 2 );
    strlcpy( piantirushConfig.autoKickExemptMsg, cfsFetchStr( cP, "piantirush.autoKickExemptMsg", 
        "Early objective capture is AUTHORIZED due to low survivors"), CFS_FETCH_MAX);   


    // training mode vars - default adds "10 minutes" to rush timers but this is only activated if
    // "piantirush.p2p.training" is nonzero (set by picladmin)
    // Default = 600 means adds 10 minutes to objective leg; high bot servers run 15 minutes so lock first 10 minutes
    //
    piantirushConfig.nPlayerExemptionTrainOffset   = (int) cfsFetchNum( cP, "piantirush.nPlayerExemptionTrainOffset",     0 );  // 0 or -1
    strlcpy( piantirushConfig.trainingModeMsg, 
        cfsFetchStr( cP, "piantirush.trainingModeMsg", "Type '11' before Breach/Detonate!" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.teamNotReadyPrompt,
        cfsFetchStr( cP, "piantirush.teamNotReadyPrompt", "Denied - Team NOT ready!" ), CFS_FETCH_MAX);
 
    // training mode undocumented vars - these are undocumented parameters - not needed by most installations
    //
    piantirushConfig.lockIntervalSecTrainOffset    = (int) cfsFetchNum( cP, "piantirush.lockIntervalSecTrainOffset",    600 );
    piantirushConfig.slowIntervalSecTrainOffset    = (int) cfsFetchNum( cP, "piantirush.slowIntervalSecTrainOffset",    600 );
    piantirushConfig.earlyBreachSpeedupTrainOffset = (int) cfsFetchNum( cP, "piantirush.earlyBreachSpeedupTrainOffset", 600 );
    piantirushConfig.destroySpeedupTrainOffset     = (int) cfsFetchNum( cP, "piantirush.destroySpeedupTrainOffset",     600 );
    piantirushConfig.trainingOnDefaultEnable       = (int) cfsFetchNum( cP, "piantirush.trainingOnDefaultEnable",         0 );
    piantirushConfig.minimumQuietTimeSec           = (int) cfsFetchNum( cP, "piantirush.minimumQuietTimeSec",             0 );

    piantirushConfig.trTimeOfs     = 0;
    piantirushConfig.trSlowOfs     = 0;
    piantirushConfig.trEarlyOfs    = 0;
    piantirushConfig.trEarDesOfs   = 0;
    piantirushConfig.trNPlayerOfs  = 0;

    // Disable Training by default.  In the future this can be copied from sissm.cfg 
    // but default "off" is good for now
    //
    p2pSetL( "piantirush.p2p.training", 0L );

    // Clear the semaphore for 'no wait' speedup request coming from 
    // picladmin
    // 
    p2pSetL( "piantirush.p2p.SigNoWait", 0L );

    // Variables for Bot Spawnkill detection (Checkpoint/Hardcore only)
    // 
    piantirushConfig.botSpawnKillWindowSec  = (int) cfsFetchNum( cP, "piantirush.botSpawnKillWindowSec", 10L ); 
    piantirushConfig.botSpawnKillMaxKills   = (int) cfsFetchNum( cP, "piantirush.botSpawnKillMaxKills",   6L );
    piantirushConfig.botSpawnKillWarnOrKick = (int) cfsFetchNum( cP, "piantirush.botSpawnKillWarnOrKick", 0L );
    strlcpy( piantirushConfig.botSpawnKillKickMessage,
        cfsFetchStr( cP, "piantirush.botSpawnKillKickMessage", "Please do not spawn-kill bots!  Try again!" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.botSpawnKillWarnMessage,
        cfsFetchStr( cP, "piantirush.botSpawnKillWarnMessage", "Please do not spawn-kill bots!" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.botSpawnKillExemptMethods,
        cfsFetchStr( cP, "piantirush.botSpawnKillExemptMethods", "" ), CFS_FETCH_MAX);


    // Variables for Bot-killing using prohibited weapons (Geneva)
    // 
    piantirushConfig.genevaDefault = (int) cfsFetchNum( cP, "piantirush.genevaDefault", 0L );    // default 1=enable 0=disable

    strlcpy( piantirushConfig.genevaKickReason,
        cfsFetchStr( cP, "piantirush.genevaKickReason", "Auto-kicked for illegal use of weapon.  Try again!" ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.genevaKickWarnMessage,
        cfsFetchStr( cP, "piantirush.genevaKickWarnMessage", "*Weapons restriction in effect: " ), CFS_FETCH_MAX);
    strlcpy( piantirushConfig.genevaWeapons, 
        cfsFetchStr( cP, "piantirush.genevaWeapons", "Molotov ANM14" ), CFS_FETCH_MAX);

    // Geneva weapons restrictions p2p variable
    p2pSetL( "piantirush.p2p.genevaKick", (long) piantirushConfig.genevaDefault  );

    cfsDestroy( cP );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8a90
movq %rax, %rdi
callq 0x9370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x93d2(%rip), %rsi      # 0x26cc6
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x201f9a(%rip)    # 0x21f8a0
movq -0x8(%rbp), %rdi
leaq 0x93cc(%rip), %rsi      # 0x26cdd
movsd 0x570f(%rip), %xmm0     # 0x23028
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x201f7c(%rip)    # 0x21f8a4
movq -0x8(%rbp), %rdi
leaq 0x93c6(%rip), %rsi      # 0x26cf9
movsd 0x5db5(%rip), %xmm0     # 0x236f0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x201f5e(%rip)    # 0x21f8a8
movq -0x8(%rbp), %rdi
leaq 0x93c4(%rip), %rsi      # 0x26d19
leaq 0x93d3(%rip), %rdx      # 0x26d2f
callq 0x9430
movq %rax, %rsi
leaq 0x201f35(%rip), %rdi    # 0x21f8a0
addq $0xc, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93ca(%rip), %rsi      # 0x26d4e
leaq 0x93e7(%rip), %rdx      # 0x26d72
callq 0x9430
movq %rax, %rsi
leaq 0x201f06(%rip), %rdi    # 0x21f8a0
addq $0x40c, %rdi            # imm = 0x40C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93bf(%rip), %rsi      # 0x26d75
leaq 0x93d8(%rip), %rdx      # 0x26d95
callq 0x9430
movq %rax, %rsi
leaq 0x201ed4(%rip), %rdi    # 0x21f8a0
addq $0x80c, %rdi            # imm = 0x80C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93b2(%rip), %rsi      # 0x26d9a
movsd 0x90d8(%rip), %xmm0     # 0x26ac8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x202aad(%rip)    # 0x2204ac
movq -0x8(%rbp), %rdi
leaq 0x93ab(%rip), %rsi      # 0x26db5
leaq 0x93ba(%rip), %rdx      # 0x26dcb
callq 0x9430
movq %rax, %rsi
leaq 0x201e80(%rip), %rdi    # 0x21f8a0
addq $0xc10, %rdi            # imm = 0xC10
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93bc(%rip), %rsi      # 0x26df8
leaq 0x7e00(%rip), %rdx      # 0x25843
callq 0x9430
movq %rax, %rsi
leaq 0x201e4e(%rip), %rdi    # 0x21f8a0
addq $0x1010, %rdi           # imm = 0x1010
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93ae(%rip), %rsi      # 0x26e1c
leaq 0x93c7(%rip), %rdx      # 0x26e3c
callq 0x9430
movq %rax, %rsi
leaq 0x201e1c(%rip), %rdi    # 0x21f8a0
addq $0x1410, %rdi           # imm = 0x1410
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93a1(%rip), %rsi      # 0x26e41
movsd 0x9018(%rip), %xmm0     # 0x26ac0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2035f9(%rip)    # 0x2210b0
movq -0x8(%rbp), %rdi
leaq 0x939a(%rip), %rsi      # 0x26e5c
leaq 0x93a9(%rip), %rdx      # 0x26e72
callq 0x9430
movq %rax, %rsi
leaq 0x201dc8(%rip), %rdi    # 0x21f8a0
addq $0x1814, %rdi           # imm = 0x1814
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x939f(%rip), %rsi      # 0x26e93
leaq 0x9ef7(%rip), %rdx      # 0x279f2
callq 0x9430
movq %rax, %rsi
leaq 0x201d96(%rip), %rdi    # 0x21f8a0
addq $0x1c14, %rdi           # imm = 0x1C14
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9391(%rip), %rsi      # 0x26eb7
leaq 0x930f(%rip), %rdx      # 0x26e3c
callq 0x9430
movq %rax, %rsi
leaq 0x201d64(%rip), %rdi    # 0x21f8a0
addq $0x2014, %rdi           # imm = 0x2014
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x937f(%rip), %rsi      # 0x26ed7
leaq 0x5bb2(%rip), %rdx      # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x201d32(%rip), %rdi    # 0x21f8a0
addq $0x2414, %rdi           # imm = 0x2414
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x936d(%rip), %rsi      # 0x26ef7
leaq 0x5b80(%rip), %rdx      # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x201d00(%rip), %rdi    # 0x21f8a0
addq $0x2814, %rdi           # imm = 0x2814
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x935d(%rip), %rsi      # 0x26f19
movsd 0x8ef4(%rip), %xmm0     # 0x26ab8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2048e1(%rip)    # 0x2224b4
movq -0x8(%rbp), %rdi
leaq 0x9359(%rip), %rsi      # 0x26f37
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2048c8(%rip)    # 0x2224b8
movq -0x8(%rbp), %rdi
leaq 0x9360(%rip), %rsi      # 0x26f5b
movsd 0x8ead(%rip), %xmm0     # 0x26ab0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2048aa(%rip)    # 0x2224bc
movq -0x8(%rbp), %rdi
leaq 0x9358(%rip), %rsi      # 0x26f75
leaq 0x936c(%rip), %rdx      # 0x26f90
callq 0x9430
movq %rax, %rsi
leaq 0x201c6d(%rip), %rdi    # 0x21f8a0
addq $0x2c20, %rdi           # imm = 0x2C20
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x936e(%rip), %rsi      # 0x26fbd
leaq 0x9384(%rip), %rdx      # 0x26fda
callq 0x9430
movq %rax, %rsi
leaq 0x201c3b(%rip), %rdi    # 0x21f8a0
addq $0x3020, %rdi           # imm = 0x3020
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x937d(%rip), %rsi      # 0x26ffe
leaq 0x9393(%rip), %rdx      # 0x2701b
callq 0x9430
movq %rax, %rsi
leaq 0x201c09(%rip), %rdi    # 0x21f8a0
addq $0x3420, %rdi           # imm = 0x3420
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x939b(%rip), %rsi      # 0x2704e
leaq 0x93b7(%rip), %rdx      # 0x27071
callq 0x9430
movq %rax, %rsi
leaq 0x201bd7(%rip), %rdi    # 0x21f8a0
addq $0x3820, %rdi           # imm = 0x3820
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93c1(%rip), %rsi      # 0x270a6
leaq 0x93df(%rip), %rdx      # 0x270cb
callq 0x9430
movq %rax, %rsi
leaq 0x201ba5(%rip), %rdi    # 0x21f8a0
addq $0x3c20, %rdi           # imm = 0x3C20
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93c8(%rip), %rsi      # 0x270df
movsd 0x59c9(%rip), %xmm0     # 0x236e8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x205b92(%rip)    # 0x2238c0
movq -0x8(%rbp), %rdi
leaq 0x93c7(%rip), %rsi      # 0x27100
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x205b79(%rip)    # 0x2238c4
movq -0x8(%rbp), %rdi
leaq 0x93c5(%rip), %rsi      # 0x2711b
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x205b60(%rip)    # 0x2238c8
movq -0x8(%rbp), %rdi
leaq 0x93c7(%rip), %rsi      # 0x2713a
movsd 0x8d35(%rip), %xmm0     # 0x26ab0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x206342(%rip)    # 0x2240cc
movq -0x8(%rbp), %rdi
leaq 0x93c3(%rip), %rsi      # 0x27158
movsd 0x8d0b(%rip), %xmm0     # 0x26aa8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x206324(%rip)    # 0x2240d0
movq -0x8(%rbp), %rdi
leaq 0x93bf(%rip), %rsi      # 0x27176
movsd 0x8ce1(%rip), %xmm0     # 0x26aa0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x206306(%rip)    # 0x2240d4
movq -0x8(%rbp), %rdi
leaq 0x93bb(%rip), %rsi      # 0x27194
leaq 0x93d8(%rip), %rdx      # 0x271b8
callq 0x9430
movq %rax, %rsi
leaq 0x201ab1(%rip), %rdi    # 0x21f8a0
addq $0x4838, %rdi           # imm = 0x4838
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93c1(%rip), %rsi      # 0x271cc
leaq 0x93e0(%rip), %rdx      # 0x271f2
callq 0x9430
movq %rax, %rsi
leaq 0x201a7f(%rip), %rdi    # 0x21f8a0
addq $0x4c38, %rdi           # imm = 0x4C38
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x93f1(%rip), %rsi      # 0x2722e
leaq 0x9412(%rip), %rdx      # 0x27256
callq 0x9430
movq %rax, %rsi
leaq 0x201a4d(%rip), %rdi    # 0x21f8a0
addq $0x5038, %rdi           # imm = 0x5038
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9415(%rip), %rsi      # 0x27284
leaq 0x9428(%rip), %rdx      # 0x2729e
callq 0x9430
movq %rax, %rsi
leaq 0x201a1b(%rip), %rdi    # 0x21f8a0
addq $0x402c, %rdi           # imm = 0x402C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9422(%rip), %rsi      # 0x272c3
leaq 0x9437(%rip), %rdx      # 0x272df
callq 0x9430
movq %rax, %rsi
leaq 0x2019e9(%rip), %rdi    # 0x21f8a0
addq $0x442c, %rdi           # imm = 0x442C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x942b(%rip), %rsi      # 0x272fe
leaq 0x943f(%rip), %rdx      # 0x27319
callq 0x9430
movq %rax, %rsi
leaq 0x2019b7(%rip), %rdi    # 0x21f8a0
addq $0x5438, %rdi           # imm = 0x5438
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x942d(%rip), %rsi      # 0x27332
leaq 0x9441(%rip), %rdx      # 0x2734d
callq 0x9430
movq %rax, %rsi
leaq 0x201985(%rip), %rdi    # 0x21f8a0
addq $0x5838, %rdi           # imm = 0x5838
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x942d(%rip), %rsi      # 0x27364
movsd 0x50e9(%rip), %xmm0     # 0x23028
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x20758a(%rip)    # 0x2254d8
movq -0x8(%rbp), %rdi
leaq 0x9428(%rip), %rsi      # 0x27381
leaq 0x943e(%rip), %rdx      # 0x2739e
callq 0x9430
movq %rax, %rsi
leaq 0x201931(%rip), %rdi    # 0x21f8a0
addq $0x5c3c, %rdi           # imm = 0x5C3C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x944e(%rip), %rsi      # 0x273d9
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x20795f(%rip)    # 0x2258fc
movq -0x8(%rbp), %rdi
leaq 0x9458(%rip), %rsi      # 0x27400
leaq 0x946c(%rip), %rdx      # 0x2741b
callq 0x9430
movq %rax, %rsi
leaq 0x2018e2(%rip), %rdi    # 0x21f8a0
addq $0x6064, %rdi           # imm = 0x6064
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9463(%rip), %rsi      # 0x2743d
leaq 0x947a(%rip), %rdx      # 0x2745b
callq 0x9430
movq %rax, %rsi
leaq 0x2018b0(%rip), %rdi    # 0x21f8a0
addq $0x6464, %rdi           # imm = 0x6464
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9468(%rip), %rsi      # 0x27474
movsd 0x8a84(%rip), %xmm0     # 0x26a98
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2078b9(%rip)    # 0x2258dc
movq -0x8(%rbp), %rdi
leaq 0x946c(%rip), %rsi      # 0x2749a
movsd 0x8a62(%rip), %xmm0     # 0x26a98
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x20789f(%rip)    # 0x2258e4
movq -0x8(%rbp), %rdi
leaq 0x9470(%rip), %rsi      # 0x274c0
movsd 0x8a40(%rip), %xmm0     # 0x26a98
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x207885(%rip)    # 0x2258ec
movq -0x8(%rbp), %rdi
leaq 0x9477(%rip), %rsi      # 0x274e9
movsd 0x8a1e(%rip), %xmm0     # 0x26a98
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x20786b(%rip)    # 0x2258f4
movq -0x8(%rbp), %rdi
leaq 0x947a(%rip), %rsi      # 0x2750e
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x20805e(%rip)    # 0x226104
movq -0x8(%rbp), %rdi
leaq 0x9480(%rip), %rsi      # 0x27531
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x208045(%rip)    # 0x226108
movl $0x0, 0x207813(%rip)    # 0x2258e0
movl $0x0, 0x207811(%rip)    # 0x2258e8
movl $0x0, 0x20780f(%rip)    # 0x2258f0
movl $0x0, 0x20780d(%rip)    # 0x2258f8
movl $0x0, 0x20780b(%rip)    # 0x225900
leaq 0x5816(%rip), %rdi      # 0x23912
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
leaq 0x5e85(%rip), %rdi      # 0x23f91
xorl %eax, %eax
movl %eax, %esi
callq 0x1ebf0
movq -0x8(%rbp), %rdi
leaq 0x9430(%rip), %rsi      # 0x27550
movsd 0x55c0(%rip), %xmm0     # 0x236e8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x207fd5(%rip)    # 0x22610c
movq -0x8(%rbp), %rdi
leaq 0x942f(%rip), %rsi      # 0x27571
movsd 0x55a6(%rip), %xmm0     # 0x236f0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x207fb7(%rip)    # 0x226110
movq -0x8(%rbp), %rdi
leaq 0x942d(%rip), %rsi      # 0x27591
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x207f9e(%rip)    # 0x226114
movq -0x8(%rbp), %rdi
leaq 0x9432(%rip), %rsi      # 0x275b3
leaq 0x944e(%rip), %rdx      # 0x275d6
callq 0x9430
movq %rax, %rsi
leaq 0x201709(%rip), %rdi    # 0x21f8a0
addq $0x6878, %rdi           # imm = 0x6878
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x944e(%rip), %rsi      # 0x27601
leaq 0x946a(%rip), %rdx      # 0x27624
callq 0x9430
movq %rax, %rsi
leaq 0x2016d7(%rip), %rdi    # 0x21f8a0
addq $0x6c78, %rdi           # imm = 0x6C78
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x945e(%rip), %rsi      # 0x27643
leaq 0x5525(%rip), %rdx      # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2016a5(%rip), %rdi    # 0x21f8a0
addq $0x7078, %rdi           # imm = 0x7078
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x9451(%rip), %rsi      # 0x27668
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x208aef(%rip)    # 0x226d18
movq -0x8(%rbp), %rdi
leaq 0x944d(%rip), %rsi      # 0x27681
leaq 0x9462(%rip), %rdx      # 0x2769d
callq 0x9430
movq %rax, %rsi
leaq 0x201656(%rip), %rdi    # 0x21f8a0
addq $0x7c7c, %rdi           # imm = 0x7C7C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x946a(%rip), %rsi      # 0x276d0
leaq 0x9484(%rip), %rdx      # 0x276f1
callq 0x9430
movq %rax, %rsi
leaq 0x201624(%rip), %rdi    # 0x21f8a0
addq $0x787c, %rdi           # imm = 0x787C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x947a(%rip), %rsi      # 0x27712
leaq 0x948c(%rip), %rdx      # 0x2772b
callq 0x9430
movq %rax, %rsi
leaq 0x2015f2(%rip), %rdi    # 0x21f8a0
addq $0x747c, %rdi           # imm = 0x747C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movslq 0x208a52(%rip), %rsi    # 0x226d18
leaq 0x55a0(%rip), %rdi      # 0x2386d
callq 0x1ebf0
movq -0x8(%rbp), %rdi
callq 0x93f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)