// File: /workspace/github_c_makefile_star2_O3/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 0x8970
movq %rax, %rdi
callq 0x8ffc
movq %rax, %rbx
leaq 0x7ad1(%rip), %rsi      # 0x1eca6
xorpd %xmm0, %xmm0
movq %rax, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2006b5(%rip)    # 0x2178a0
leaq 0x7acb(%rip), %rsi      # 0x1ecbd
movsd 0x3e0e(%rip), %xmm0     # 0x1b008
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x200698(%rip)    # 0x2178a4
leaq 0x7ac6(%rip), %rsi      # 0x1ecd9
movsd 0x44d5(%rip), %xmm0     # 0x1b6f0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20067b(%rip)    # 0x2178a8
leaq 0x7ac5(%rip), %rsi      # 0x1ecf9
leaq 0x7ad4(%rip), %rdx      # 0x1ed0f
movq %rbx, %rdi
callq 0x9073
leaq 0x200662(%rip), %rdi    # 0x2178ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ad0(%rip), %rsi      # 0x1ed2e
leaq 0x7aed(%rip), %rdx      # 0x1ed52
movq %rbx, %rdi
callq 0x9073
leaq 0x200a38(%rip), %rdi    # 0x217cac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7acd(%rip), %rsi      # 0x1ed55
leaq 0x7ae6(%rip), %rdx      # 0x1ed75
movq %rbx, %rdi
callq 0x9073
leaq 0x200e0e(%rip), %rdi    # 0x2180ac
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ac8(%rip), %rsi      # 0x1ed7a
movsd 0x77b6(%rip), %xmm0     # 0x1ea70
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2011e0(%rip)    # 0x2184ac
leaq 0x7ac2(%rip), %rsi      # 0x1ed95
leaq 0x7ad1(%rip), %rdx      # 0x1edab
movq %rbx, %rdi
callq 0x9073
leaq 0x2011c7(%rip), %rdi    # 0x2184b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7adb(%rip), %rsi      # 0x1edd8
leaq 0x6516(%rip), %rdx      # 0x1d81a
movq %rbx, %rdi
callq 0x9073
leaq 0x20159d(%rip), %rdi    # 0x2188b0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ad5(%rip), %rsi      # 0x1edfc
leaq 0x7aee(%rip), %r14      # 0x1ee1c
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9073
leaq 0x201970(%rip), %rdi    # 0x218cb0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7acd(%rip), %rsi      # 0x1ee21
movsd 0x771c(%rip), %xmm0     # 0x1ea78
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x201d42(%rip)    # 0x2190b0
leaq 0x7ac7(%rip), %rsi      # 0x1ee3c
leaq 0x7ad6(%rip), %rdx      # 0x1ee52
movq %rbx, %rdi
callq 0x9073
leaq 0x201d29(%rip), %rdi    # 0x2190b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ad4(%rip), %rsi      # 0x1ee73
leaq 0x862c(%rip), %rdx      # 0x1f9d2
movq %rbx, %rdi
callq 0x9073
leaq 0x2020ff(%rip), %rdi    # 0x2194b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ace(%rip), %rsi      # 0x1ee97
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9073
leaq 0x2024d9(%rip), %rdi    # 0x2198b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ac8(%rip), %rsi      # 0x1eeb7
leaq 0x4313(%rip), %r14      # 0x1b709
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9073
leaq 0x2028ac(%rip), %rdi    # 0x219cb4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7abb(%rip), %rsi      # 0x1eed7
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9073
leaq 0x202c86(%rip), %rdi    # 0x21a0b4
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ab7(%rip), %rsi      # 0x1eef9
movsd 0x7636(%rip), %xmm0     # 0x1ea80
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x203058(%rip)    # 0x21a4b4
leaq 0x7ab4(%rip), %rsi      # 0x1ef17
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20303f(%rip)    # 0x21a4b8
leaq 0x7abb(%rip), %rsi      # 0x1ef3b
movsd 0x7600(%rip), %xmm0     # 0x1ea88
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x203022(%rip)    # 0x21a4bc
leaq 0x7ab4(%rip), %rsi      # 0x1ef55
leaq 0x7ac8(%rip), %rdx      # 0x1ef70
movq %rbx, %rdi
callq 0x9073
leaq 0x203009(%rip), %rdi    # 0x21a4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ad2(%rip), %rsi      # 0x1ef9d
leaq 0x7ae8(%rip), %rdx      # 0x1efba
movq %rbx, %rdi
callq 0x9073
leaq 0x2033df(%rip), %rdi    # 0x21a8c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7ae9(%rip), %rsi      # 0x1efde
leaq 0x7aff(%rip), %rdx      # 0x1effb
movq %rbx, %rdi
callq 0x9073
leaq 0x2037b5(%rip), %rdi    # 0x21acc0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7b0f(%rip), %rsi      # 0x1f02e
leaq 0x7b2b(%rip), %rdx      # 0x1f051
movq %rbx, %rdi
callq 0x9073
leaq 0x203b8b(%rip), %rdi    # 0x21b0c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7b3d(%rip), %rsi      # 0x1f086
leaq 0x7b5b(%rip), %rdx      # 0x1f0ab
movq %rbx, %rdi
callq 0x9073
leaq 0x203f61(%rip), %rdi    # 0x21b4c0
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7b4c(%rip), %rsi      # 0x1f0bf
movsd 0x415d(%rip), %xmm0     # 0x1b6d8
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x204333(%rip)    # 0x21b8c0
leaq 0x7b4c(%rip), %rsi      # 0x1f0e0
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20431a(%rip)    # 0x21b8c4
leaq 0x7b4a(%rip), %rsi      # 0x1f0fb
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x204301(%rip)    # 0x21b8c8
leaq 0x7b4c(%rip), %rsi      # 0x1f11a
movq %rbx, %rdi
movsd 0x74af(%rip), %xmm0     # 0x1ea88
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x204ae4(%rip)    # 0x21c0cc
leaq 0x7b49(%rip), %rsi      # 0x1f138
movsd 0x7499(%rip), %xmm0     # 0x1ea90
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x204ac7(%rip)    # 0x21c0d0
leaq 0x7b46(%rip), %rsi      # 0x1f156
movsd 0x7480(%rip), %xmm0     # 0x1ea98
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x204aaa(%rip)    # 0x21c0d4
leaq 0x7b43(%rip), %rsi      # 0x1f174
leaq 0x7b60(%rip), %rdx      # 0x1f198
movq %rbx, %rdi
callq 0x9073
leaq 0x204a91(%rip), %rdi    # 0x21c0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7b51(%rip), %rsi      # 0x1f1ac
leaq 0x7b70(%rip), %rdx      # 0x1f1d2
movq %rbx, %rdi
callq 0x9073
leaq 0x204e67(%rip), %rdi    # 0x21c4d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7b89(%rip), %rsi      # 0x1f20e
leaq 0x7baa(%rip), %rdx      # 0x1f236
movq %rbx, %rdi
callq 0x9073
leaq 0x20523d(%rip), %rdi    # 0x21c8d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7bb5(%rip), %rsi      # 0x1f264
leaq 0x7bc8(%rip), %rdx      # 0x1f27e
movq %rbx, %rdi
callq 0x9073
leaq 0x204207(%rip), %rdi    # 0x21b8cc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7bca(%rip), %rsi      # 0x1f2a3
leaq 0x7bdf(%rip), %rdx      # 0x1f2bf
movq %rbx, %rdi
callq 0x9073
leaq 0x2045dd(%rip), %rdi    # 0x21bccc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7bdb(%rip), %rsi      # 0x1f2de
leaq 0x7bef(%rip), %rdx      # 0x1f2f9
movq %rbx, %rdi
callq 0x9073
leaq 0x2055bf(%rip), %rdi    # 0x21ccd8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7be5(%rip), %rsi      # 0x1f312
leaq 0x7bf9(%rip), %rdx      # 0x1f32d
movq %rbx, %rdi
callq 0x9073
leaq 0x205995(%rip), %rdi    # 0x21d0d8
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7bed(%rip), %rsi      # 0x1f344
movq %rbx, %rdi
movsd 0x38a6(%rip), %xmm0     # 0x1b008
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x205d67(%rip)    # 0x21d4d8
leaq 0x7be9(%rip), %rsi      # 0x1f361
leaq 0x7bff(%rip), %rdx      # 0x1f37e
movq %rbx, %rdi
callq 0x9073
leaq 0x205d4e(%rip), %rdi    # 0x21d4dc
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c17(%rip), %rsi      # 0x1f3b9
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x206144(%rip)    # 0x21d8fc
leaq 0x7c21(%rip), %rsi      # 0x1f3e0
leaq 0x7c35(%rip), %rdx      # 0x1f3fb
movq %rbx, %rdi
callq 0x9073
leaq 0x20612f(%rip), %rdi    # 0x21d904
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c34(%rip), %rsi      # 0x1f41d
leaq 0x7c4b(%rip), %rdx      # 0x1f43b
movq %rbx, %rdi
callq 0x9073
leaq 0x206505(%rip), %rdi    # 0x21dd04
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c41(%rip), %rsi      # 0x1f454
movsd 0x7285(%rip), %xmm0     # 0x1eaa0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2060af(%rip)    # 0x21d8dc
leaq 0x7c46(%rip), %rsi      # 0x1f47a
movq %rbx, %rdi
movsd 0x7261(%rip), %xmm0     # 0x1eaa0
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x206096(%rip)    # 0x21d8e4
leaq 0x7c4b(%rip), %rsi      # 0x1f4a0
movq %rbx, %rdi
movsd 0x7240(%rip), %xmm0     # 0x1eaa0
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20607d(%rip)    # 0x21d8ec
leaq 0x7c53(%rip), %rsi      # 0x1f4c9
movq %rbx, %rdi
movsd 0x721f(%rip), %xmm0     # 0x1eaa0
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x206064(%rip)    # 0x21d8f4
leaq 0x7c57(%rip), %rsi      # 0x1f4ee
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x206857(%rip)    # 0x21e104
leaq 0x7c5d(%rip), %rsi      # 0x1f511
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20683e(%rip)    # 0x21e108
xorl %eax, %eax
movl %eax, 0x20600e(%rip)    # 0x21d8e0
movl %eax, 0x206010(%rip)    # 0x21d8e8
movl %eax, 0x206012(%rip)    # 0x21d8f0
movl %eax, 0x206014(%rip)    # 0x21d8f8
movl %eax, 0x206016(%rip)    # 0x21d900
leaq 0x4019(%rip), %rdi      # 0x1b90a
xorl %esi, %esi
callq 0x180a5
leaq 0x468a(%rip), %rdi      # 0x1bf89
xorl %esi, %esi
callq 0x180a5
leaq 0x7c23(%rip), %rsi      # 0x1f530
movq %rbx, %rdi
movsd 0x3dc0(%rip), %xmm0     # 0x1b6d8
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2067e5(%rip)    # 0x21e10c
leaq 0x7c23(%rip), %rsi      # 0x1f551
movq %rbx, %rdi
movsd 0x3db7(%rip), %xmm0     # 0x1b6f0
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2067c8(%rip)    # 0x21e110
leaq 0x7c22(%rip), %rsi      # 0x1f571
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x2067af(%rip)    # 0x21e114
leaq 0x7c27(%rip), %rsi      # 0x1f593
leaq 0x7c43(%rip), %rdx      # 0x1f5b6
movq %rbx, %rdi
callq 0x9073
leaq 0x206796(%rip), %rdi    # 0x21e118
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c4b(%rip), %rsi      # 0x1f5e1
leaq 0x7c67(%rip), %rdx      # 0x1f604
movq %rbx, %rdi
callq 0x9073
leaq 0x206b6c(%rip), %rdi    # 0x21e518
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c63(%rip), %rsi      # 0x1f623
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9073
leaq 0x206f46(%rip), %rdi    # 0x21e918
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c62(%rip), %rsi      # 0x1f648
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x926a
cvttsd2si %xmm0, %eax
movl %eax, 0x20731c(%rip)    # 0x21ed18
leaq 0x7c5e(%rip), %rsi      # 0x1f661
leaq 0x7c73(%rip), %rdx      # 0x1f67d
movq %rbx, %rdi
callq 0x9073
leaq 0x207b03(%rip), %rdi    # 0x21f51c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c83(%rip), %rsi      # 0x1f6b0
leaq 0x7c9d(%rip), %rdx      # 0x1f6d1
movq %rbx, %rdi
callq 0x9073
leaq 0x2076d9(%rip), %rdi    # 0x21f11c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
leaq 0x7c9b(%rip), %rsi      # 0x1f6f2
leaq 0x7cad(%rip), %rdx      # 0x1f70b
movq %rbx, %rdi
callq 0x9073
leaq 0x2072af(%rip), %rdi    # 0x21ed1c
movl $0x400, %edx            # imm = 0x400
movq %rax, %rsi
callq 0xf384
movslq 0x207297(%rip), %rsi    # 0x21ed18
leaq 0x3ddd(%rip), %rdi      # 0x1b865
callq 0x180a5
movq %rbx, %rdi
callq 0x9054
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq