// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/picladmin.c
// Function: picladminInitConfig
int picladminInitConfig( void )
{
    cfsPtr cP;
    int i;
    char varArray[256];

    _queueReboot = REBOOT_CANCEL;

    cP = cfsCreate( sissmGetConfigPath() );

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

    // Read the humanized responses for when a command is issued can was successfully executed
    //
    strlcpy( picladminConfig.msgOk[0],       cfsFetchStr( cP, "picladmin.msgOk[0]",      "Ok!" ),             CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgOk[1],       cfsFetchStr( cP, "picladmin.msgOk[1]",      "Ok!" ),             CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgOk[2],       cfsFetchStr( cP, "picladmin.msgOk[2]",      "Ok!" ),             CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgOk[3],       cfsFetchStr( cP, "picladmin.msgOk[3]",      "Ok!" ),             CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgOk[4],       cfsFetchStr( cP, "picladmin.msgOk[4]",      "Ok!" ),             CFS_FETCH_MAX);

    // Read the humanized responses for when a command has an error
    //
    strlcpy( picladminConfig.msgErr[0],      cfsFetchStr( cP, "picladmin.msgErr[0]",     "Invalid Syntax!" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgErr[1],      cfsFetchStr( cP, "picladmin.msgErr[1]",     "Invalid Syntax!" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgErr[2],      cfsFetchStr( cP, "picladmin.msgErr[2]",     "Invalid Syntax!" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgErr[3],      cfsFetchStr( cP, "picladmin.msgErr[3]",     "Invalid Syntax!" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgErr[4],      cfsFetchStr( cP, "picladmin.msgErr[4]",     "Invalid Syntax!" ), CFS_FETCH_MAX);

    // Read the humanized responses for when a non-admin tries to use a command
    //
    strlcpy( picladminConfig.msgInvalid[0], cfsFetchStr( cP, "picladmin.msgInvalid[0]",  "Unauthorized!" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgInvalid[1], cfsFetchStr( cP, "picladmin.msgInvalid[1]",  "Unauthroized!" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgInvalid[2], cfsFetchStr( cP, "picladmin.msgInvalid[2]",  "Unauthroized!" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgInvalid[3], cfsFetchStr( cP, "picladmin.msgInvalid[3]",  "Unauthroized!" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.msgInvalid[4], cfsFetchStr( cP, "picladmin.msgInvalid[4]",  "Unauthorized!" ),   CFS_FETCH_MAX);


    // Read the 5-element rules list
    //
    strlcpy( picladminConfig.rulesInfo[0], cfsFetchStr( cP, "picladmin.rulesInfo[0]",  "" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.rulesInfo[1], cfsFetchStr( cP, "picladmin.rulesInfo[1]",  "" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.rulesInfo[2], cfsFetchStr( cP, "picladmin.rulesInfo[2]",  "" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.rulesInfo[3], cfsFetchStr( cP, "picladmin.rulesInfo[3]",  "" ),   CFS_FETCH_MAX);
    strlcpy( picladminConfig.rulesInfo[4], cfsFetchStr( cP, "picladmin.rulesInfo[4]",  "" ),   CFS_FETCH_MAX);

    // Read the interval (sec) on how fast the rules are printed on player screen.  0 = no rules
    //
    picladminConfig.rulesIntervalSec = (int) cfsFetchNum( cP, "picladmin.rulesIntervalSec", 2.0 );  //  2sec apart

    // Read the server contacts info
    //
    strlcpy( picladminConfig.contactInfo, cfsFetchStr( cP, "picladmin.contactInfo",  "Contact info not set" ),   CFS_FETCH_MAX);

    // Read the operator-specified "macro" (alias) sequence
    //
    for ( i=0; i<NUM_MACROS; i++ ) {
        snprintf( varArray, 256, "picladmin.macros[%d]", i );
        strlcpy( picladminConfig.macros[i],     cfsFetchStr( cP, varArray,  "" ),   CFS_FETCH_MAX);
        replaceDoubleColonWithBell( picladminConfig.macros[i] );
    }

    strlcpy( picladminConfig.cmdPrefix,      cfsFetchStr( cP, "picladmin.cmdPrefix",      "!" ),              CFS_FETCH_MAX);

    // if nil cmdPrefix is in the .cfg file, this will cause every command to be admin command, so
    // we override that here.
    //
    if ( 0 == strlen( picladminConfig.cmdPrefix )) strlcpy( picladminConfig.cmdPrefix, "!", CFS_FETCH_MAX );

    // Set bot count max and default min values 
    // if Max value is set too high and admin issues a !bf or !bs, servers & clients may crash
    //
    picladminConfig.botMaxAllowed = (int) cfsFetchNum( cP, "picladmin.botMaxAllowed", 200.0 );
    picladminConfig.botMinDefault = (int) cfsFetchNum( cP, "picladmin.botMinDefault",  6.0 );
    if ( picladminConfig.botMaxAllowed < 2 ) picladminConfig.botMaxAllowed = 4;
    if ( picladminConfig.botMinDefault < 2 ) picladminConfig.botMinDefault = 2;

    // BotUpperMin limits the maximum number admin can specify in !botscaled !bs command.
    // Recommended value:  10.  If "0" is set (default) the limiter is disabled.
    //
    picladminConfig.botUpperMin = (int) cfsFetchNum( cP, "picladmin.botUpperMin", 0.0 );

    // text to show in-game for !ask, !prep, and !warn
    //
    strlcpy( picladminConfig.prepBlow, cfsFetchStr( cP, "picladmin.prepBlow",  
        "*Planting/Ready to detonate!" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.prepCapture, cfsFetchStr( cP, "picladmin.prepCapture",  
        "*Testing Capture Point - Stepping On then Off" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.askBlow, cfsFetchStr( cP, "picladmin.askBlow",  
        "*DETONATING in 5-sec, <NEGATIVE> to halt" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.askCapture, cfsFetchStr( cP, "picladmin.askCapture",  
        "*BREACHING in 5-sec, <NEGATIVE> to halt" ), CFS_FETCH_MAX);
    strlcpy( picladminConfig.warnRusher, cfsFetchStr( cP, "picladmin.warnRusher",  
        "*Do NOT BREACH/DETONATE CACHE without ASKING TEAM" ), CFS_FETCH_MAX);

    // Read the "reasons" preset strings for ban/banid/kick/kickid commmands
    //
    for ( i=0; i<NUM_REASONS; i++ ) {
        snprintf( varArray, 256, "picladmin.reason[%d]", i );
        strlcpy( picladminConfig.reason[i],     cfsFetchStr( cP, varArray,  "" ),   CFS_FETCH_MAX);
        replaceDoubleColonWithBell( picladminConfig.reason[i] );
    }

    // Read the temp ban duration in minutes
    //
    picladminConfig.tempBanMinutes = (int) cfsFetchNum( cP, "picladmin.tempBanMinutes", 1440.0 );

    // Read the nokick exemption (from antirush autokick) window time in seconds
    //
    picladminConfig.noKickProtectSec = (int) cfsFetchNum( cP, "picladmin.noKickProtectSec",  15.0 );
    if ( picladminConfig.noKickProtectSec < 0 ) picladminConfig.noKickProtectSec = 0;

    // Info text that is shown when a player types !strict
    //
    strlcpy( picladminConfig.strictTutorial,  cfsFetchStr( cP, "picladmin.strictTutorial",
        "*Auto-kick if no '11' before breach/detonate!"), 
        CFS_FETCH_MAX);

    cfsDestroy( cP );
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, 0x58947(%rip)     # 0x65d5c
callq 0x8a90
movq %rax, %rdi
callq 0x9370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16de4(%rip), %rsi     # 0x24215
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x2f4fd(%rip)     # 0x3c940
movq -0x8(%rbp), %rdi
leaq 0x16ddd(%rip), %rsi     # 0x2422b
leaq 0x16de9(%rip), %rdx     # 0x2423e
callq 0x9430
movq %rax, %rsi
leaq 0x2f4dc(%rip), %rdi     # 0x3c940
addq $0x4, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16dc5(%rip), %rsi     # 0x24242
leaq 0x16dba(%rip), %rdx     # 0x2423e
callq 0x9430
movq %rax, %rsi
leaq 0x2f4ad(%rip), %rdi     # 0x3c940
addq $0x4, %rdi
addq $0x400, %rdi            # imm = 0x400
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16da2(%rip), %rsi     # 0x24255
leaq 0x16d84(%rip), %rdx     # 0x2423e
callq 0x9430
movq %rax, %rsi
leaq 0x2f477(%rip), %rdi     # 0x3c940
addq $0x4, %rdi
addq $0x800, %rdi            # imm = 0x800
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16d7f(%rip), %rsi     # 0x24268
leaq 0x16d4e(%rip), %rdx     # 0x2423e
callq 0x9430
movq %rax, %rsi
leaq 0x2f441(%rip), %rdi     # 0x3c940
addq $0x4, %rdi
addq $0xc00, %rdi            # imm = 0xC00
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16d5c(%rip), %rsi     # 0x2427b
leaq 0x16d18(%rip), %rdx     # 0x2423e
callq 0x9430
movq %rax, %rsi
leaq 0x2f40b(%rip), %rdi     # 0x3c940
addq $0x4, %rdi
addq $0x1000, %rdi           # imm = 0x1000
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16d39(%rip), %rsi     # 0x2428e
leaq 0x16d46(%rip), %rdx     # 0x242a2
callq 0x9430
movq %rax, %rsi
leaq 0x2f3d5(%rip), %rdi     # 0x3c940
addq $0x1404, %rdi           # imm = 0x1404
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16d2b(%rip), %rsi     # 0x242b2
leaq 0x16d14(%rip), %rdx     # 0x242a2
callq 0x9430
movq %rax, %rsi
leaq 0x2f3a3(%rip), %rdi     # 0x3c940
addq $0x1404, %rdi           # imm = 0x1404
addq $0x400, %rdi            # imm = 0x400
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16d06(%rip), %rsi     # 0x242c6
leaq 0x16cdb(%rip), %rdx     # 0x242a2
callq 0x9430
movq %rax, %rsi
leaq 0x2f36a(%rip), %rdi     # 0x3c940
addq $0x1404, %rdi           # imm = 0x1404
addq $0x800, %rdi            # imm = 0x800
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16ce1(%rip), %rsi     # 0x242da
leaq 0x16ca2(%rip), %rdx     # 0x242a2
callq 0x9430
movq %rax, %rsi
leaq 0x2f331(%rip), %rdi     # 0x3c940
addq $0x1404, %rdi           # imm = 0x1404
addq $0xc00, %rdi            # imm = 0xC00
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16cbc(%rip), %rsi     # 0x242ee
leaq 0x16c69(%rip), %rdx     # 0x242a2
callq 0x9430
movq %rax, %rsi
leaq 0x2f2f8(%rip), %rdi     # 0x3c940
addq $0x1404, %rdi           # imm = 0x1404
addq $0x1000, %rdi           # imm = 0x1000
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c97(%rip), %rsi     # 0x24302
leaq 0x16ca8(%rip), %rdx     # 0x2431a
callq 0x9430
movq %rax, %rsi
leaq 0x2f2bf(%rip), %rdi     # 0x3c940
addq $0x2804, %rdi           # imm = 0x2804
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c8b(%rip), %rsi     # 0x24328
leaq 0x16c9c(%rip), %rdx     # 0x24340
callq 0x9430
movq %rax, %rsi
leaq 0x2f28d(%rip), %rdi     # 0x3c940
addq $0x2804, %rdi           # imm = 0x2804
addq $0x400, %rdi            # imm = 0x400
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c78(%rip), %rsi     # 0x2434e
leaq 0x16c63(%rip), %rdx     # 0x24340
callq 0x9430
movq %rax, %rsi
leaq 0x2f254(%rip), %rdi     # 0x3c940
addq $0x2804, %rdi           # imm = 0x2804
addq $0x800, %rdi            # imm = 0x800
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c57(%rip), %rsi     # 0x24366
leaq 0x16c2a(%rip), %rdx     # 0x24340
callq 0x9430
movq %rax, %rsi
leaq 0x2f21b(%rip), %rdi     # 0x3c940
addq $0x2804, %rdi           # imm = 0x2804
addq $0xc00, %rdi            # imm = 0xC00
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c36(%rip), %rsi     # 0x2437e
leaq 0x16bcb(%rip), %rdx     # 0x2431a
callq 0x9430
movq %rax, %rsi
leaq 0x2f1e2(%rip), %rdi     # 0x3c940
addq $0x2804, %rdi           # imm = 0x2804
addq $0x1000, %rdi           # imm = 0x1000
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16c15(%rip), %rsi     # 0x24396
leaq 0x15f89(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2f1a9(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16bfa(%rip), %rsi     # 0x243ad
leaq 0x15f57(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2f177(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
addq $0x400, %rdi            # imm = 0x400
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16bd8(%rip), %rsi     # 0x243c4
leaq 0x15f1e(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2f13e(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
addq $0x800, %rdi            # imm = 0x800
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16bb6(%rip), %rsi     # 0x243db
leaq 0x15ee5(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2f105(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
addq $0xc00, %rdi            # imm = 0xC00
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16b94(%rip), %rsi     # 0x243f2
leaq 0x15eac(%rip), %rdx     # 0x23711
callq 0x9430
movq %rax, %rsi
leaq 0x2f0cc(%rip), %rdi     # 0x3c940
addq $0x27c10, %rdi          # imm = 0x27C10
addq $0x1000, %rdi           # imm = 0x1000
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16b72(%rip), %rsi     # 0x24409
movsd 0x15789(%rip), %xmm0    # 0x23028
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x580a2(%rip)     # 0x65950
movq -0x8(%rbp), %rdi
leaq 0x16b6b(%rip), %rsi     # 0x24424
leaq 0x16b7a(%rip), %rdx     # 0x2443a
callq 0x9430
movq %rax, %rsi
leaq 0x2f071(%rip), %rdi     # 0x3c940
addq $0x27810, %rdi          # imm = 0x27810
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0xd987
leaq -0x110(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x100, %esi            # imm = 0x100
leaq 0x16b45(%rip), %rdx     # 0x2444f
movb $0x0, %al
callq 0x8180
movslq -0xc(%rbp), %rcx
leaq 0x2f024(%rip), %rax     # 0x3c940
addq $0x4004, %rax           # imm = 0x4004
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq 0x15dcf(%rip), %rdx     # 0x23711
callq 0x9430
movq -0x118(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movslq -0xc(%rbp), %rax
leaq 0x2efda(%rip), %rdi     # 0x3c940
addq $0x4004, %rdi           # imm = 0x4004
shlq $0xa, %rax
addq %rax, %rdi
callq 0x127c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd8e7
movq -0x8(%rbp), %rdi
leaq 0x16ad2(%rip), %rsi     # 0x24464
leaq 0x1ae52(%rip), %rdx     # 0x287eb
callq 0x9430
movq %rax, %rsi
leaq 0x2ef98(%rip), %rdi     # 0x3c940
addq $0x3c04, %rdi           # imm = 0x3C04
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
leaq 0x32b84(%rip), %rdi     # 0x40544
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xd9ee
leaq 0x2ef6a(%rip), %rdi     # 0x3c940
addq $0x3c04, %rdi           # imm = 0x3C04
leaq 0x1ae07(%rip), %rsi     # 0x287eb
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16a7f(%rip), %rsi     # 0x24478
movsd 0x15cf7(%rip), %xmm0    # 0x236f8
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x52f34(%rip)     # 0x60944
movq -0x8(%rbp), %rdi
leaq 0x16a75(%rip), %rsi     # 0x24490
movsd 0x15ccd(%rip), %xmm0    # 0x236f0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x52f16(%rip)     # 0x60948
cmpl $0x2, 0x52f0b(%rip)     # 0x60944
jge 0xda45
movl $0x4, 0x52eff(%rip)     # 0x60944
cmpl $0x2, 0x52efc(%rip)     # 0x60948
jge 0xda58
movl $0x2, 0x52ef0(%rip)     # 0x60948
movq -0x8(%rbp), %rdi
leaq 0x16a45(%rip), %rsi     # 0x244a8
xorps %xmm0, %xmm0
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x52ed7(%rip)     # 0x6094c
movq -0x8(%rbp), %rdi
leaq 0x16a3e(%rip), %rsi     # 0x244be
leaq 0x16a4a(%rip), %rdx     # 0x244d1
callq 0x9430
movq %rax, %rsi
leaq 0x2eeaa(%rip), %rdi     # 0x3c940
addq $0x24010, %rdi          # imm = 0x24010
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16a3c(%rip), %rsi     # 0x244ee
leaq 0x16a4b(%rip), %rdx     # 0x24504
callq 0x9430
movq %rax, %rsi
leaq 0x2ee78(%rip), %rdi     # 0x3c940
addq $0x24410, %rdi          # imm = 0x24410
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16a4e(%rip), %rsi     # 0x24532
leaq 0x16a59(%rip), %rdx     # 0x24544
callq 0x9430
movq %rax, %rsi
leaq 0x2ee46(%rip), %rdi     # 0x3c940
addq $0x24810, %rdi          # imm = 0x24810
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16a57(%rip), %rsi     # 0x2456d
leaq 0x16a65(%rip), %rdx     # 0x24582
callq 0x9430
movq %rax, %rsi
leaq 0x2ee14(%rip), %rdi     # 0x3c940
addq $0x24c10, %rdi          # imm = 0x24C10
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
leaq 0x16a62(%rip), %rsi     # 0x245aa
leaq 0x16a70(%rip), %rdx     # 0x245bf
callq 0x9430
movq %rax, %rsi
leaq 0x2ede2(%rip), %rdi     # 0x3c940
addq $0x25010, %rdi          # imm = 0x25010
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0xdc13
leaq -0x110(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x100, %esi            # imm = 0x100
leaq 0x16a5b(%rip), %rdx     # 0x245f1
movb $0x0, %al
callq 0x8180
movslq -0xc(%rbp), %rcx
leaq 0x2ed98(%rip), %rax     # 0x3c940
addq $0x25410, %rax          # imm = 0x25410
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, -0x120(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq 0x15b43(%rip), %rdx     # 0x23711
callq 0x9430
movq -0x120(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movslq -0xc(%rbp), %rax
leaq 0x2ed4e(%rip), %rdi     # 0x3c940
addq $0x25410, %rdi          # imm = 0x25410
shlq $0xa, %rax
addq %rax, %rdi
callq 0x127c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdb76
movq -0x8(%rbp), %rdi
leaq 0x169e8(%rip), %rsi     # 0x24606
movsd 0x15ae2(%rip), %xmm0    # 0x23708
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x57d1f(%rip)     # 0x65954
movq -0x8(%rbp), %rdi
leaq 0x169df(%rip), %rsi     # 0x2461f
movsd 0x15ab8(%rip), %xmm0    # 0x23700
callq 0x97d0
cvttsd2si %xmm0, %eax
movl %eax, 0x57d01(%rip)     # 0x65958
cmpl $0x0, 0x57cfa(%rip)     # 0x65958
jge 0xdc6a
movl $0x0, 0x57cee(%rip)     # 0x65958
movq -0x8(%rbp), %rdi
leaq 0x169c5(%rip), %rsi     # 0x2463a
leaq 0x169d7(%rip), %rdx     # 0x24653
callq 0x9430
movq %rax, %rsi
leaq 0x2ecb5(%rip), %rdi     # 0x3c940
addq $0x2901c, %rdi          # imm = 0x2901C
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x8(%rbp), %rdi
callq 0x93f0
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq