// File: /workspace/github_c_makefile_star2_O2/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 0x8973
movq %rax, %rdi
callq 0x8f80
movq %rax, %rbx
leaq 0x7ae9(%rip), %rsi      # 0x1dc8e
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2016e5(%rip)    # 0x2178a0
leaq 0x7ae3(%rip), %rsi      # 0x1dca5
movsd 0x3e3e(%rip), %xmm0     # 0x1a008
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2016c8(%rip)    # 0x2178a4
leaq 0x7ade(%rip), %rsi      # 0x1dcc1
movsd 0x4505(%rip), %xmm0     # 0x1a6f0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2016ab(%rip)    # 0x2178a8
leaq 0x7add(%rip), %rsi      # 0x1dce1
leaq 0x7aec(%rip), %rdx      # 0x1dcf7
movq %rbx, %rdi
callq 0x8ff5
leaq 0x201692(%rip), %rdi    # 0x2178ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae8(%rip), %rsi      # 0x1dd16
leaq 0x7b05(%rip), %rdx      # 0x1dd3a
movq %rbx, %rdi
callq 0x8ff5
leaq 0x201a68(%rip), %rdi    # 0x217cac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae5(%rip), %rsi      # 0x1dd3d
leaq 0x7afe(%rip), %rdx      # 0x1dd5d
movq %rbx, %rdi
callq 0x8ff5
leaq 0x201e3e(%rip), %rdi    # 0x2180ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae0(%rip), %rsi      # 0x1dd62
movsd 0x77d6(%rip), %xmm0     # 0x1da60
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x202210(%rip)    # 0x2184ac
leaq 0x7ada(%rip), %rsi      # 0x1dd7d
leaq 0x7ae9(%rip), %rdx      # 0x1dd93
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2021f7(%rip), %rdi    # 0x2184b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7af3(%rip), %rsi      # 0x1ddc0
leaq 0x654e(%rip), %rdx      # 0x1c822
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2025cd(%rip), %rdi    # 0x2188b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7aed(%rip), %rsi      # 0x1dde4
leaq 0x7b06(%rip), %r14      # 0x1de04
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ff5
leaq 0x2029a0(%rip), %rdi    # 0x218cb0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae5(%rip), %rsi      # 0x1de09
movsd 0x773c(%rip), %xmm0     # 0x1da68
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x202d72(%rip)    # 0x2190b0
leaq 0x7adf(%rip), %rsi      # 0x1de24
leaq 0x7aee(%rip), %rdx      # 0x1de3a
movq %rbx, %rdi
callq 0x8ff5
leaq 0x202d59(%rip), %rdi    # 0x2190b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7aec(%rip), %rsi      # 0x1de5b
leaq 0x8644(%rip), %rdx      # 0x1e9ba
movq %rbx, %rdi
callq 0x8ff5
leaq 0x20312f(%rip), %rdi    # 0x2194b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae6(%rip), %rsi      # 0x1de7f
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ff5
leaq 0x203509(%rip), %rdi    # 0x2198b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ae0(%rip), %rsi      # 0x1de9f
leaq 0x4343(%rip), %r14      # 0x1a709
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ff5
leaq 0x2038dc(%rip), %rdi    # 0x219cb4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ad3(%rip), %rsi      # 0x1debf
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ff5
leaq 0x203cb6(%rip), %rdi    # 0x21a0b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7acf(%rip), %rsi      # 0x1dee1
movsd 0x7656(%rip), %xmm0     # 0x1da70
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x204088(%rip)    # 0x21a4b4
leaq 0x7acc(%rip), %rsi      # 0x1deff
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x20406f(%rip)    # 0x21a4b8
leaq 0x7ad3(%rip), %rsi      # 0x1df23
movsd 0x7620(%rip), %xmm0     # 0x1da78
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x204052(%rip)    # 0x21a4bc
leaq 0x7acc(%rip), %rsi      # 0x1df3d
leaq 0x7ae0(%rip), %rdx      # 0x1df58
movq %rbx, %rdi
callq 0x8ff5
leaq 0x204039(%rip), %rdi    # 0x21a4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7aea(%rip), %rsi      # 0x1df85
leaq 0x7b00(%rip), %rdx      # 0x1dfa2
movq %rbx, %rdi
callq 0x8ff5
leaq 0x20440f(%rip), %rdi    # 0x21a8c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7b01(%rip), %rsi      # 0x1dfc6
leaq 0x7b17(%rip), %rdx      # 0x1dfe3
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2047e5(%rip), %rdi    # 0x21acc0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7b27(%rip), %rsi      # 0x1e016
leaq 0x7b43(%rip), %rdx      # 0x1e039
movq %rbx, %rdi
callq 0x8ff5
leaq 0x204bbb(%rip), %rdi    # 0x21b0c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7b55(%rip), %rsi      # 0x1e06e
leaq 0x7b73(%rip), %rdx      # 0x1e093
movq %rbx, %rdi
callq 0x8ff5
leaq 0x204f91(%rip), %rdi    # 0x21b4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7b64(%rip), %rsi      # 0x1e0a7
movsd 0x418d(%rip), %xmm0     # 0x1a6d8
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x205363(%rip)    # 0x21b8c0
leaq 0x7b64(%rip), %rsi      # 0x1e0c8
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x20534a(%rip)    # 0x21b8c4
leaq 0x7b62(%rip), %rsi      # 0x1e0e3
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x205331(%rip)    # 0x21b8c8
leaq 0x7b64(%rip), %rsi      # 0x1e102
movq %rbx, %rdi
movsd 0x74cf(%rip), %xmm0     # 0x1da78
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x205b14(%rip)    # 0x21c0cc
leaq 0x7b61(%rip), %rsi      # 0x1e120
movsd 0x74b9(%rip), %xmm0     # 0x1da80
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x205af7(%rip)    # 0x21c0d0
leaq 0x7b5e(%rip), %rsi      # 0x1e13e
movsd 0x74a0(%rip), %xmm0     # 0x1da88
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x205ada(%rip)    # 0x21c0d4
leaq 0x7b5b(%rip), %rsi      # 0x1e15c
leaq 0x7b78(%rip), %rdx      # 0x1e180
movq %rbx, %rdi
callq 0x8ff5
leaq 0x205ac1(%rip), %rdi    # 0x21c0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7b69(%rip), %rsi      # 0x1e194
leaq 0x7b88(%rip), %rdx      # 0x1e1ba
movq %rbx, %rdi
callq 0x8ff5
leaq 0x205e97(%rip), %rdi    # 0x21c4d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7ba1(%rip), %rsi      # 0x1e1f6
leaq 0x7bc2(%rip), %rdx      # 0x1e21e
movq %rbx, %rdi
callq 0x8ff5
leaq 0x20626d(%rip), %rdi    # 0x21c8d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7bcd(%rip), %rsi      # 0x1e24c
leaq 0x7be0(%rip), %rdx      # 0x1e266
movq %rbx, %rdi
callq 0x8ff5
leaq 0x205237(%rip), %rdi    # 0x21b8cc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7be2(%rip), %rsi      # 0x1e28b
leaq 0x7bf7(%rip), %rdx      # 0x1e2a7
movq %rbx, %rdi
callq 0x8ff5
leaq 0x20560d(%rip), %rdi    # 0x21bccc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7bf3(%rip), %rsi      # 0x1e2c6
leaq 0x7c07(%rip), %rdx      # 0x1e2e1
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2065ef(%rip), %rdi    # 0x21ccd8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7bfd(%rip), %rsi      # 0x1e2fa
leaq 0x7c11(%rip), %rdx      # 0x1e315
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2069c5(%rip), %rdi    # 0x21d0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c05(%rip), %rsi      # 0x1e32c
movq %rbx, %rdi
movsd 0x38d6(%rip), %xmm0     # 0x1a008
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x206d97(%rip)    # 0x21d4d8
leaq 0x7c01(%rip), %rsi      # 0x1e349
leaq 0x7c17(%rip), %rdx      # 0x1e366
movq %rbx, %rdi
callq 0x8ff5
leaq 0x206d7e(%rip), %rdi    # 0x21d4dc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c2f(%rip), %rsi      # 0x1e3a1
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x207174(%rip)    # 0x21d8fc
leaq 0x7c39(%rip), %rsi      # 0x1e3c8
leaq 0x7c4d(%rip), %rdx      # 0x1e3e3
movq %rbx, %rdi
callq 0x8ff5
leaq 0x20715f(%rip), %rdi    # 0x21d904
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c4c(%rip), %rsi      # 0x1e405
leaq 0x7c63(%rip), %rdx      # 0x1e423
movq %rbx, %rdi
callq 0x8ff5
leaq 0x207535(%rip), %rdi    # 0x21dd04
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c59(%rip), %rsi      # 0x1e43c
movsd 0x72a5(%rip), %xmm0     # 0x1da90
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2070df(%rip)    # 0x21d8dc
leaq 0x7c5e(%rip), %rsi      # 0x1e462
movq %rbx, %rdi
movsd 0x7281(%rip), %xmm0     # 0x1da90
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2070c6(%rip)    # 0x21d8e4
leaq 0x7c63(%rip), %rsi      # 0x1e488
movq %rbx, %rdi
movsd 0x7260(%rip), %xmm0     # 0x1da90
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2070ad(%rip)    # 0x21d8ec
leaq 0x7c6b(%rip), %rsi      # 0x1e4b1
movq %rbx, %rdi
movsd 0x723f(%rip), %xmm0     # 0x1da90
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x207094(%rip)    # 0x21d8f4
leaq 0x7c6f(%rip), %rsi      # 0x1e4d6
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x207887(%rip)    # 0x21e104
leaq 0x7c75(%rip), %rsi      # 0x1e4f9
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x20786e(%rip)    # 0x21e108
andl $0x0, 0x20703f(%rip)    # 0x21d8e0
andl $0x0, 0x207040(%rip)    # 0x21d8e8
andl $0x0, 0x207041(%rip)    # 0x21d8f0
andl $0x0, 0x207042(%rip)    # 0x21d8f8
andl $0x0, 0x207043(%rip)    # 0x21d900
leaq 0x4046(%rip), %rdi      # 0x1a90a
xorl %esi, %esi
callq 0x17049
leaq 0x46b7(%rip), %rdi      # 0x1af89
xorl %esi, %esi
callq 0x17049
leaq 0x7c38(%rip), %rsi      # 0x1e518
movq %rbx, %rdi
movsd 0x3ded(%rip), %xmm0     # 0x1a6d8
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x207812(%rip)    # 0x21e10c
leaq 0x7c38(%rip), %rsi      # 0x1e539
movq %rbx, %rdi
movsd 0x3de4(%rip), %xmm0     # 0x1a6f0
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2077f5(%rip)    # 0x21e110
leaq 0x7c37(%rip), %rsi      # 0x1e559
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x2077dc(%rip)    # 0x21e114
leaq 0x7c3c(%rip), %rsi      # 0x1e57b
leaq 0x7c58(%rip), %rdx      # 0x1e59e
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2077c3(%rip), %rdi    # 0x21e118
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c60(%rip), %rsi      # 0x1e5c9
leaq 0x7c7c(%rip), %rdx      # 0x1e5ec
movq %rbx, %rdi
callq 0x8ff5
leaq 0x207b99(%rip), %rdi    # 0x21e518
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c78(%rip), %rsi      # 0x1e60b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ff5
leaq 0x207f73(%rip), %rdi    # 0x21e918
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c77(%rip), %rsi      # 0x1e630
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x91bd
cvttsd2si %xmm0, %eax
movl %eax, 0x208349(%rip)    # 0x21ed18
leaq 0x7c73(%rip), %rsi      # 0x1e649
leaq 0x7c88(%rip), %rdx      # 0x1e665
movq %rbx, %rdi
callq 0x8ff5
leaq 0x208b30(%rip), %rdi    # 0x21f51c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7c98(%rip), %rsi      # 0x1e698
leaq 0x7cb2(%rip), %rdx      # 0x1e6b9
movq %rbx, %rdi
callq 0x8ff5
leaq 0x208706(%rip), %rdi    # 0x21f11c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
leaq 0x7cb0(%rip), %rsi      # 0x1e6da
leaq 0x7cc2(%rip), %rdx      # 0x1e6f3
movq %rbx, %rdi
callq 0x8ff5
leaq 0x2082dc(%rip), %rdi    # 0x21ed1c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xe97a
movslq 0x2082c4(%rip), %rsi    # 0x21ed18
leaq 0x3e0a(%rip), %rdi      # 0x1a865
callq 0x17049
movq %rbx, %rdi
callq 0x8fd6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq