// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
callq 0x8969
movq %rax, %rdi
callq 0x9004
movq %rax, %rbx
leaq 0x7cfc(%rip), %rsi      # 0x1ecbe
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2008c8(%rip)    # 0x2178a0
leaq 0x7cf6(%rip), %rsi      # 0x1ecd5
movsd 0x4021(%rip), %xmm0     # 0x1b008
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2008ab(%rip)    # 0x2178a4
leaq 0x7cf1(%rip), %rsi      # 0x1ecf1
movsd 0x46f0(%rip), %xmm0     # 0x1b6f8
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x20088e(%rip)    # 0x2178a8
leaq 0x7cf0(%rip), %rsi      # 0x1ed11
leaq 0x7cff(%rip), %rdx      # 0x1ed27
movq %rbx, %rdi
callq 0x907b
leaq 0x200875(%rip), %rdi    # 0x2178ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cfb(%rip), %rsi      # 0x1ed46
leaq 0x7d18(%rip), %rdx      # 0x1ed6a
movq %rbx, %rdi
callq 0x907b
leaq 0x200c4b(%rip), %rdi    # 0x217cac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cf8(%rip), %rsi      # 0x1ed6d
leaq 0x7d11(%rip), %rdx      # 0x1ed8d
movq %rbx, %rdi
callq 0x907b
leaq 0x201021(%rip), %rdi    # 0x2180ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cf3(%rip), %rsi      # 0x1ed92
movsd 0x79e1(%rip), %xmm0     # 0x1ea88
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2013f3(%rip)    # 0x2184ac
leaq 0x7ced(%rip), %rsi      # 0x1edad
leaq 0x7cfc(%rip), %rdx      # 0x1edc3
movq %rbx, %rdi
callq 0x907b
leaq 0x2013da(%rip), %rdi    # 0x2184b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d06(%rip), %rsi      # 0x1edf0
leaq 0x6751(%rip), %rdx      # 0x1d842
movq %rbx, %rdi
callq 0x907b
leaq 0x2017b0(%rip), %rdi    # 0x2188b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d00(%rip), %rsi      # 0x1ee14
leaq 0x7d19(%rip), %r14      # 0x1ee34
movq %rbx, %rdi
movq %r14, %rdx
callq 0x907b
leaq 0x201b83(%rip), %rdi    # 0x218cb0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cf8(%rip), %rsi      # 0x1ee39
movsd 0x7947(%rip), %xmm0     # 0x1ea90
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x201f55(%rip)    # 0x2190b0
leaq 0x7cf2(%rip), %rsi      # 0x1ee54
leaq 0x7d01(%rip), %rdx      # 0x1ee6a
movq %rbx, %rdi
callq 0x907b
leaq 0x201f3c(%rip), %rdi    # 0x2190b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cff(%rip), %rsi      # 0x1ee8b
leaq 0x8857(%rip), %rdx      # 0x1f9ea
movq %rbx, %rdi
callq 0x907b
leaq 0x202312(%rip), %rdi    # 0x2194b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cf9(%rip), %rsi      # 0x1eeaf
movq %rbx, %rdi
movq %r14, %rdx
callq 0x907b
leaq 0x2026ec(%rip), %rdi    # 0x2198b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cf3(%rip), %rsi      # 0x1eecf
leaq 0x452e(%rip), %r14      # 0x1b711
movq %rbx, %rdi
movq %r14, %rdx
callq 0x907b
leaq 0x202abf(%rip), %rdi    # 0x219cb4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7ce6(%rip), %rsi      # 0x1eeef
movq %rbx, %rdi
movq %r14, %rdx
callq 0x907b
leaq 0x202e99(%rip), %rdi    # 0x21a0b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7ce2(%rip), %rsi      # 0x1ef11
movsd 0x7861(%rip), %xmm0     # 0x1ea98
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x20326b(%rip)    # 0x21a4b4
leaq 0x7cdf(%rip), %rsi      # 0x1ef2f
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x203252(%rip)    # 0x21a4b8
leaq 0x7ce6(%rip), %rsi      # 0x1ef53
movsd 0x782b(%rip), %xmm0     # 0x1eaa0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x203235(%rip)    # 0x21a4bc
leaq 0x7cdf(%rip), %rsi      # 0x1ef6d
leaq 0x7cf3(%rip), %rdx      # 0x1ef88
movq %rbx, %rdi
callq 0x907b
leaq 0x20321c(%rip), %rdi    # 0x21a4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7cfd(%rip), %rsi      # 0x1efb5
leaq 0x7d13(%rip), %rdx      # 0x1efd2
movq %rbx, %rdi
callq 0x907b
leaq 0x2035f2(%rip), %rdi    # 0x21a8c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d14(%rip), %rsi      # 0x1eff6
leaq 0x7d2a(%rip), %rdx      # 0x1f013
movq %rbx, %rdi
callq 0x907b
leaq 0x2039c8(%rip), %rdi    # 0x21acc0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d3a(%rip), %rsi      # 0x1f046
leaq 0x7d56(%rip), %rdx      # 0x1f069
movq %rbx, %rdi
callq 0x907b
leaq 0x203d9e(%rip), %rdi    # 0x21b0c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d68(%rip), %rsi      # 0x1f09e
leaq 0x7d86(%rip), %rdx      # 0x1f0c3
movq %rbx, %rdi
callq 0x907b
leaq 0x204174(%rip), %rdi    # 0x21b4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d77(%rip), %rsi      # 0x1f0d7
movsd 0x4378(%rip), %xmm0     # 0x1b6e0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x204546(%rip)    # 0x21b8c0
leaq 0x7d77(%rip), %rsi      # 0x1f0f8
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x20452d(%rip)    # 0x21b8c4
leaq 0x7d75(%rip), %rsi      # 0x1f113
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x204514(%rip)    # 0x21b8c8
leaq 0x7d77(%rip), %rsi      # 0x1f132
movq %rbx, %rdi
movsd 0x76da(%rip), %xmm0     # 0x1eaa0
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x204cf7(%rip)    # 0x21c0cc
leaq 0x7d74(%rip), %rsi      # 0x1f150
movsd 0x76c4(%rip), %xmm0     # 0x1eaa8
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x204cda(%rip)    # 0x21c0d0
leaq 0x7d71(%rip), %rsi      # 0x1f16e
movsd 0x76ab(%rip), %xmm0     # 0x1eab0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x204cbd(%rip)    # 0x21c0d4
leaq 0x7d6e(%rip), %rsi      # 0x1f18c
leaq 0x7d8b(%rip), %rdx      # 0x1f1b0
movq %rbx, %rdi
callq 0x907b
leaq 0x204ca4(%rip), %rdi    # 0x21c0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7d7c(%rip), %rsi      # 0x1f1c4
leaq 0x7d9b(%rip), %rdx      # 0x1f1ea
movq %rbx, %rdi
callq 0x907b
leaq 0x20507a(%rip), %rdi    # 0x21c4d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7db4(%rip), %rsi      # 0x1f226
leaq 0x7dd5(%rip), %rdx      # 0x1f24e
movq %rbx, %rdi
callq 0x907b
leaq 0x205450(%rip), %rdi    # 0x21c8d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7de0(%rip), %rsi      # 0x1f27c
leaq 0x7df3(%rip), %rdx      # 0x1f296
movq %rbx, %rdi
callq 0x907b
leaq 0x20441a(%rip), %rdi    # 0x21b8cc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7df5(%rip), %rsi      # 0x1f2bb
leaq 0x7e0a(%rip), %rdx      # 0x1f2d7
movq %rbx, %rdi
callq 0x907b
leaq 0x2047f0(%rip), %rdi    # 0x21bccc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e06(%rip), %rsi      # 0x1f2f6
leaq 0x7e1a(%rip), %rdx      # 0x1f311
movq %rbx, %rdi
callq 0x907b
leaq 0x2057d2(%rip), %rdi    # 0x21ccd8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e10(%rip), %rsi      # 0x1f32a
leaq 0x7e24(%rip), %rdx      # 0x1f345
movq %rbx, %rdi
callq 0x907b
leaq 0x205ba8(%rip), %rdi    # 0x21d0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e18(%rip), %rsi      # 0x1f35c
movq %rbx, %rdi
movsd 0x3ab9(%rip), %xmm0     # 0x1b008
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x205f7a(%rip)    # 0x21d4d8
leaq 0x7e14(%rip), %rsi      # 0x1f379
leaq 0x7e2a(%rip), %rdx      # 0x1f396
movq %rbx, %rdi
callq 0x907b
leaq 0x205f61(%rip), %rdi    # 0x21d4dc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e42(%rip), %rsi      # 0x1f3d1
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x206357(%rip)    # 0x21d8fc
leaq 0x7e4c(%rip), %rsi      # 0x1f3f8
leaq 0x7e60(%rip), %rdx      # 0x1f413
movq %rbx, %rdi
callq 0x907b
leaq 0x206342(%rip), %rdi    # 0x21d904
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e5f(%rip), %rsi      # 0x1f435
leaq 0x7e76(%rip), %rdx      # 0x1f453
movq %rbx, %rdi
callq 0x907b
leaq 0x206718(%rip), %rdi    # 0x21dd04
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e6c(%rip), %rsi      # 0x1f46c
movsd 0x74b0(%rip), %xmm0     # 0x1eab8
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2062c2(%rip)    # 0x21d8dc
leaq 0x7e71(%rip), %rsi      # 0x1f492
movq %rbx, %rdi
movsd 0x748c(%rip), %xmm0     # 0x1eab8
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2062a9(%rip)    # 0x21d8e4
leaq 0x7e76(%rip), %rsi      # 0x1f4b8
movq %rbx, %rdi
movsd 0x746b(%rip), %xmm0     # 0x1eab8
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x206290(%rip)    # 0x21d8ec
leaq 0x7e7e(%rip), %rsi      # 0x1f4e1
movq %rbx, %rdi
movsd 0x744a(%rip), %xmm0     # 0x1eab8
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x206277(%rip)    # 0x21d8f4
leaq 0x7e82(%rip), %rsi      # 0x1f506
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x206a6a(%rip)    # 0x21e104
leaq 0x7e88(%rip), %rsi      # 0x1f529
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x206a51(%rip)    # 0x21e108
xorl %eax, %eax
movl %eax, 0x206221(%rip)    # 0x21d8e0
movl %eax, 0x206223(%rip)    # 0x21d8e8
movl %eax, 0x206225(%rip)    # 0x21d8f0
movl %eax, 0x206227(%rip)    # 0x21d8f8
movl %eax, 0x206229(%rip)    # 0x21d900
leaq 0x4234(%rip), %rdi      # 0x1b912
xorl %esi, %esi
callq 0x17ea8
leaq 0x48a5(%rip), %rdi      # 0x1bf91
xorl %esi, %esi
callq 0x17ea8
leaq 0x7e4e(%rip), %rsi      # 0x1f548
movq %rbx, %rdi
movsd 0x3fdb(%rip), %xmm0     # 0x1b6e0
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2069f8(%rip)    # 0x21e10c
leaq 0x7e4e(%rip), %rsi      # 0x1f569
movq %rbx, %rdi
movsd 0x3fd2(%rip), %xmm0     # 0x1b6f8
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2069db(%rip)    # 0x21e110
leaq 0x7e4d(%rip), %rsi      # 0x1f589
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x2069c2(%rip)    # 0x21e114
leaq 0x7e52(%rip), %rsi      # 0x1f5ab
leaq 0x7e6e(%rip), %rdx      # 0x1f5ce
movq %rbx, %rdi
callq 0x907b
leaq 0x2069a9(%rip), %rdi    # 0x21e118
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e76(%rip), %rsi      # 0x1f5f9
leaq 0x7e92(%rip), %rdx      # 0x1f61c
movq %rbx, %rdi
callq 0x907b
leaq 0x206d7f(%rip), %rdi    # 0x21e518
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e8e(%rip), %rsi      # 0x1f63b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x907b
leaq 0x207159(%rip), %rdi    # 0x21e918
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7e8d(%rip), %rsi      # 0x1f660
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x9276
cvttsd2si %xmm0, %eax
movl %eax, 0x20752f(%rip)    # 0x21ed18
leaq 0x7e89(%rip), %rsi      # 0x1f679
leaq 0x7e9e(%rip), %rdx      # 0x1f695
movq %rbx, %rdi
callq 0x907b
leaq 0x207d16(%rip), %rdi    # 0x21f51c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7eae(%rip), %rsi      # 0x1f6c8
leaq 0x7ec8(%rip), %rdx      # 0x1f6e9
movq %rbx, %rdi
callq 0x907b
leaq 0x2078ec(%rip), %rdi    # 0x21f11c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
leaq 0x7ec6(%rip), %rsi      # 0x1f70a
leaq 0x7ed8(%rip), %rdx      # 0x1f723
movq %rbx, %rdi
callq 0x907b
leaq 0x2074c2(%rip), %rdi    # 0x21ed1c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf038
movslq 0x2074aa(%rip), %rsi    # 0x21ed18
leaq 0x3ff8(%rip), %rdi      # 0x1b86d
callq 0x17ea8
movq %rbx, %rdi
callq 0x905c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq