// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/server.c
// Function: genDiscntInfoString
sds genDiscntInfoString(char *section) {
    sds info = sdsempty();
    time_t uptime = server.unixtime-server.stat_starttime;
    int j, numcommands;
    struct rusage self_ru, c_ru;
    unsigned long lol, bib;
    int allsections = 0, defsections = 0;
    int sections = 0;

    if (section == NULL) section = "default";
    allsections = strcasecmp(section,"all") == 0;
    defsections = strcasecmp(section,"default") == 0;

    getrusage(RUSAGE_SELF, &self_ru);
    getrusage(RUSAGE_CHILDREN, &c_ru);
    getClientsMaxBuffers(&lol,&bib);

    /* Server */
    if (allsections || defsections || !strcasecmp(section,"server")) {
        static int call_uname = 1;
        static struct utsname name;

        if (sections++) info = sdscat(info,"\r\n");

        if (call_uname) {
            /* Uname can be slow and is always the same output. Cache it. */
            uname(&name);
            call_uname = 0;
        }

        info = sdscatprintf(info,
            "# Server\r\n"
            "discnt_version:%s\r\n"
            "discnt_git_sha1:%s\r\n"
            "discnt_git_dirty:%d\r\n"
            "discnt_build_id:%llx\r\n"
            "os:%s %s %s\r\n"
            "arch_bits:%d\r\n"
            "multiplexing_api:%s\r\n"
            "gcc_version:%d.%d.%d\r\n"
            "process_id:%ld\r\n"
            "run_id:%s\r\n"
            "tcp_port:%d\r\n"
            "uptime_in_seconds:%jd\r\n"
            "uptime_in_days:%jd\r\n"
            "hz:%d\r\n"
            "executable:%s\r\n"
            "config_file:%s\r\n",
            DISCNT_VERSION,
            discntGitSHA1(),
            strtol(discntGitDirty(),NULL,10) > 0,
            (unsigned long long) discntBuildId(),
            name.sysname, name.release, name.machine,
            server.arch_bits,
            aeGetApiName(),
#ifdef __GNUC__
            __GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__,
#else
            0,0,0,
#endif
            (long) getpid(),
            server.runid,
            server.port,
            (intmax_t)uptime,
            (intmax_t)(uptime/(3600*24)),
            server.hz,
            server.executable ? server.executable : "",
            server.configfile ? server.configfile : "");
    }

    /* Clients */
    if (allsections || defsections || !strcasecmp(section,"clients")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Clients\r\n"
            "connected_clients:%lu\r\n"
            "client_longest_output_list:%lu\r\n"
            "client_biggest_input_buf:%lu\r\n"
            "blocked_clients:%d\r\n",
            listLength(server.clients),
            lol, bib,
            server.bpop_blocked_clients);
    }

    /* Memory */
    if (allsections || defsections || !strcasecmp(section,"memory")) {
        char hmem[64];
        char peak_hmem[64];
        size_t zmalloc_used = zmalloc_used_memory();

        /* Peak memory is updated from time to time by serverCron() so it
         * may happen that the instantaneous value is slightly bigger than
         * the peak value. This may confuse users, so we update the peak
         * if found smaller than the current memory usage. */
        if (zmalloc_used > server.stat_peak_memory)
            server.stat_peak_memory = zmalloc_used;

        bytesToHuman(hmem,zmalloc_used);
        bytesToHuman(peak_hmem,server.stat_peak_memory);
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Memory\r\n"
            "used_memory:%zu\r\n"
            "used_memory_human:%s\r\n"
            "used_memory_rss:%zu\r\n"
            "used_memory_peak:%zu\r\n"
            "used_memory_peak_human:%s\r\n"
            "mem_fragmentation_ratio:%.2f\r\n"
            "mem_allocator:%s\r\n",
            zmalloc_used,
            hmem,
            server.resident_set_size,
            server.stat_peak_memory,
            peak_hmem,
            zmalloc_get_fragmentation_ratio(server.resident_set_size),
            ZMALLOC_LIB
            );
    }

    /* Counters */
    if (allsections || defsections || !strcasecmp(section,"counters")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Counters\r\n"
            "counters:%lu\r\n"
            "hits:%lld\r\n"
            "misses:%lld\r\n",
            dictSize(server.counters),
            server.stat_hits,
            server.stat_misses);
    }

    /* Persistence */
    if (allsections || defsections || !strcasecmp(section,"persistence")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Persistence\r\n"
            "loading:%d\r\n"
            "ddb_changes_since_last_save:%lld\r\n"
            "ddb_bgsave_in_progress:%d\r\n"
            "ddb_last_save_time:%jd\r\n"
            "ddb_last_bgsave_status:%s\r\n"
            "ddb_last_bgsave_time_sec:%jd\r\n"
            "ddb_current_bgsave_time_sec:%jd\r\n",
            server.loading,
            server.dirty,
            server.ddb_child_pid != -1,
            (intmax_t)server.lastsave,
            (server.lastbgsave_status == C_OK) ? "ok" : "err",
            (intmax_t)server.ddb_save_time_last,
            (intmax_t)((server.ddb_child_pid == -1) ?
                -1 : time(NULL)-server.ddb_save_time_start));

        if (server.loading) {
            double perc;
            time_t eta, elapsed;
            off_t remaining_bytes = server.loading_total_bytes-
                                    server.loading_loaded_bytes;

            perc = ((double)server.loading_loaded_bytes /
                   server.loading_total_bytes) * 100;

            elapsed = server.unixtime-server.loading_start_time;
            if (elapsed == 0) {
                eta = 1; /* A fake 1 second figure if we don't have
                            enough info */
            } else {
                eta = (elapsed*remaining_bytes)/server.loading_loaded_bytes;
            }

            info = sdscatprintf(info,
                "loading_start_time:%jd\r\n"
                "loading_total_bytes:%llu\r\n"
                "loading_loaded_bytes:%llu\r\n"
                "loading_loaded_perc:%.2f\r\n"
                "loading_eta_seconds:%jd\r\n",
                (intmax_t) server.loading_start_time,
                (unsigned long long) server.loading_total_bytes,
                (unsigned long long) server.loading_loaded_bytes,
                perc,
                (intmax_t)eta
            );
        }
    }

    /* Stats */
    if (allsections || defsections || !strcasecmp(section,"stats")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
            "# Stats\r\n"
            "total_connections_received:%lld\r\n"
            "total_commands_processed:%lld\r\n"
            "instantaneous_ops_per_sec:%lld\r\n"
            "total_net_input_bytes:%lld\r\n"
            "total_net_output_bytes:%lld\r\n"
            "instantaneous_input_kbps:%.2f\r\n"
            "instantaneous_output_kbps:%.2f\r\n"
            "rejected_connections:%lld\r\n"
            "latest_fork_usec:%lld\r\n",
            server.stat_numconnections,
            server.stat_numcommands,
            getInstantaneousMetric(STAT_METRIC_COMMAND),
            server.stat_net_input_bytes,
            server.stat_net_output_bytes,
            (float)getInstantaneousMetric(STAT_METRIC_NET_INPUT)/1024,
            (float)getInstantaneousMetric(STAT_METRIC_NET_OUTPUT)/1024,
            server.stat_rejected_conn,
            server.stat_fork_time);
    }

    /* CPU */
    if (allsections || defsections || !strcasecmp(section,"cpu")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info,
        "# CPU\r\n"
        "used_cpu_sys:%.2f\r\n"
        "used_cpu_user:%.2f\r\n"
        "used_cpu_sys_children:%.2f\r\n"
        "used_cpu_user_children:%.2f\r\n",
        (float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000,
        (float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000,
        (float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000,
        (float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000);
    }

    /* cmdtime */
    if (allsections || !strcasecmp(section,"commandstats")) {
        if (sections++) info = sdscat(info,"\r\n");
        info = sdscatprintf(info, "# Commandstats\r\n");
        numcommands = sizeof(serverCommandTable)/sizeof(struct serverCommand);
        for (j = 0; j < numcommands; j++) {
            struct serverCommand *c = serverCommandTable+j;

            if (!c->calls) continue;
            info = sdscatprintf(info,
                "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
                c->name, c->calls, c->microseconds,
                (c->calls == 0) ? 0 : ((float)c->microseconds/c->calls));
        }
    }

    return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
movq %rdi, -0x30(%rbp)
callq 0x1e290
movq %rax, -0x38(%rbp)
movq 0xa3168(%rip), %rax     # 0xbf730
subq 0xa2e89(%rip), %rax     # 0xbf458
movq %rax, -0x40(%rbp)
movl $0x0, -0x17c(%rbp)
movl $0x0, -0x180(%rbp)
movl $0x0, -0x184(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1c603
leaq 0x87d59(%rip), %rax     # 0xa4358
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x8a90f(%rip), %rsi     # 0xa6f1d
callq 0x12070
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x17c(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x87d29(%rip), %rsi     # 0xa4358
callq 0x12070
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x180(%rbp)
xorl %edi, %edi
leaq -0xd8(%rbp), %rsi
callq 0x12770
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x168(%rbp), %rsi
callq 0x12770
leaq -0x170(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x26970
cmpl $0x0, -0x17c(%rbp)
jne 0x1c6a2
cmpl $0x0, -0x180(%rbp)
jne 0x1c6a2
movq -0x30(%rbp), %rdi
leaq 0x87ccc(%rip), %rsi     # 0xa4360
callq 0x12070
cmpl $0x0, %eax
jne 0x1c8e8
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1c6cc
movq -0x38(%rbp), %rdi
leaq 0x8989c(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
cmpl $0x0, 0xa272d(%rip)     # 0xbee00
je 0x1c6eb
leaq 0xb6d04(%rip), %rdi     # 0xd33e0
callq 0x12310
movl $0x0, 0xa2715(%rip)     # 0xbee00
movq -0x38(%rbp), %rax
movq %rax, -0x298(%rbp)
callq 0x23370
movq %rax, -0x290(%rbp)
callq 0x23380
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x124f0
cmpq $0x0, %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x284(%rbp)
callq 0x23390
movq %rax, -0x280(%rbp)
movl 0xa2a04(%rip), %eax     # 0xbf140
movl %eax, -0x274(%rbp)
callq 0x14580
movq %rax, -0x270(%rbp)
callq 0x121d0
cltq
movq %rax, -0x268(%rbp)
movl 0xa2a3a(%rip), %eax     # 0xbf19c
movl %eax, -0x25c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x40(%rbp), %rax
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
movq %rax, -0x250(%rbp)
movl 0xa297a(%rip), %eax     # 0xbf108
movl %eax, -0x244(%rbp)
cmpq $0x0, 0xa295c(%rip)     # 0xbf0f8
je 0x1c7ae
movq 0xa2953(%rip), %rax     # 0xbf0f8
movq %rax, -0x2a0(%rbp)
jmp 0x1c7be
leaq 0x895bd(%rip), %rax     # 0xa5d72
movq %rax, -0x2a0(%rbp)
jmp 0x1c7be
movq -0x2a0(%rbp), %rax
movq %rax, -0x2a8(%rbp)
cmpq $0x0, 0xa291c(%rip)     # 0xbf0f0
je 0x1c7e6
movq 0xa2913(%rip), %rax     # 0xbf0f0
movq %rax, -0x2b0(%rbp)
jmp 0x1c7f6
leaq 0x89585(%rip), %rax     # 0xa5d72
movq %rax, -0x2b0(%rbp)
jmp 0x1c7f6
movq -0x258(%rbp), %r14
movl -0x25c(%rbp), %r15d
movq -0x268(%rbp), %r13
movq -0x280(%rbp), %r9
movl -0x284(%rbp), %r8d
movq -0x290(%rbp), %rcx
movq -0x298(%rbp), %rdi
movq -0x2b0(%rbp), %rax
leaq 0x87b32(%rip), %rsi     # 0xa4367
leaq 0x888b1(%rip), %rdx     # 0xa50ed
leaq 0xb6b9d(%rip), %rbx     # 0xd33e0
movq %rbx, %r11
addq $0x82, %r11
movq %rbx, %r10
addq $0x104, %r10            # imm = 0x104
leaq 0xa288a(%rip), %r12     # 0xbf0e8
addq $0x60, %r12
movq %rbx, (%rsp)
movq -0x250(%rbp), %rbx
movq %r11, 0x8(%rsp)
movl -0x244(%rbp), %r11d
movq %r10, 0x10(%rsp)
movl -0x274(%rbp), %r10d
movl %r10d, 0x18(%rsp)
movq -0x270(%rbp), %r10
movq %r10, 0x20(%rsp)
movq -0x2a8(%rbp), %r10
movl $0x4, 0x28(%rsp)
movl $0x2, 0x30(%rsp)
movl $0x1, 0x38(%rsp)
movq %r13, 0x40(%rsp)
movq %r12, 0x48(%rsp)
movl %r15d, 0x50(%rsp)
movq %r14, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
movl %r11d, 0x68(%rsp)
movq %r10, 0x70(%rsp)
movq %rax, 0x78(%rsp)
movb $0x0, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1c90f
cmpl $0x0, -0x180(%rbp)
jne 0x1c90f
movq -0x30(%rbp), %rdi
leaq 0x89d0f(%rip), %rsi     # 0xa6614
callq 0x12070
cmpl $0x0, %eax
jne 0x1c96f
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1c939
movq -0x38(%rbp), %rdi
leaq 0x8962f(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq 0xa2984(%rip), %rax     # 0xbf2c8
movq 0x28(%rax), %rdx
movq -0x170(%rbp), %rcx
movq -0x178(%rbp), %r8
movl 0xa2dbb(%rip), %r9d     # 0xbf718
leaq 0x87b1f(%rip), %rsi     # 0xa4483
movb $0x0, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1c99a
cmpl $0x0, -0x180(%rbp)
jne 0x1c99a
movq -0x30(%rbp), %rdi
leaq 0x88657(%rip), %rsi     # 0xa4fe3
callq 0x12070
cmpl $0x0, %eax
jne 0x1cac1
callq 0x20de0
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
cmpq 0xa2abc(%rip), %rax     # 0xbf470
jbe 0x1c9c4
movq -0x218(%rbp), %rax
movq %rax, 0xa2aac(%rip)     # 0xbf470
leaq -0x1d0(%rbp), %rdi
movq -0x218(%rbp), %rsi
callq 0x1c360
leaq -0x210(%rbp), %rdi
movq 0xa2a8b(%rip), %rsi     # 0xbf470
callq 0x1c360
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1ca14
movq -0x38(%rbp), %rdi
leaq 0x89554(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x2e0(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x1d0(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movq 0xa2a4e(%rip), %rax     # 0xbf490
movq %rax, -0x2c8(%rbp)
movq 0xa2a20(%rip), %rax     # 0xbf470
movq %rax, -0x2c0(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movq 0xa2a24(%rip), %rdi     # 0xbf490
callq 0x21010
movq -0x2e0(%rbp), %rdi
movq -0x2d8(%rbp), %rdx
movq -0x2d0(%rbp), %rcx
movq -0x2c8(%rbp), %r8
movq -0x2c0(%rbp), %r9
movq -0x2b8(%rbp), %r10
cvtss2sd %xmm0, %xmm0
leaq 0x87a52(%rip), %rsi     # 0xa44f8
leaq 0x87af3(%rip), %rax     # 0xa45a0
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x1, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1cae8
cmpl $0x0, -0x180(%rbp)
jne 0x1cae8
movq -0x30(%rbp), %rdi
leaq 0x87ad1(%rip), %rsi     # 0xa45af
callq 0x12070
cmpl $0x0, %eax
jne 0x1cb4c
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1cb12
movq -0x38(%rbp), %rdi
leaq 0x89456(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq 0xa2be3(%rip), %rax     # 0xbf700
movq 0x28(%rax), %rdx
movq 0xa2bd8(%rip), %rax     # 0xbf700
addq 0x48(%rax), %rdx
movq 0xa2975(%rip), %rcx     # 0xbf4a8
movq 0xa2976(%rip), %r8      # 0xbf4b0
leaq 0x87a77(%rip), %rsi     # 0xa45b8
movb $0x0, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1cb77
cmpl $0x0, -0x180(%rbp)
jne 0x1cb77
movq -0x30(%rbp), %rdi
leaq 0x87a82(%rip), %rsi     # 0xa45eb
callq 0x12070
cmpl $0x0, %eax
jne 0x1cd73
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1cba1
movq -0x38(%rbp), %rdi
leaq 0x893c7(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x318(%rbp)
movl 0xa2856(%rip), %eax     # 0xbf408
movl %eax, -0x30c(%rbp)
movq 0xa2bc9(%rip), %rax     # 0xbf788
movq %rax, -0x308(%rbp)
cmpl $-0x1, 0xa2bcb(%rip)    # 0xbf798
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2fc(%rbp)
movq 0xa2bde(%rip), %rax     # 0xbf7c0
movq %rax, -0x2f8(%rbp)
movl 0xa2bf5(%rip), %edx     # 0xbf7e4
leaq 0x87acf(%rip), %rax     # 0xa46c5
leaq 0x87ac5(%rip), %rcx     # 0xa46c2
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x2f0(%rbp)
movq 0xa2bbe(%rip), %rax     # 0xbf7d0
movq %rax, -0x2e8(%rbp)
cmpl $-0x1, 0xa2b78(%rip)    # 0xbf798
jne 0x1cc32
movq $-0x1, %rax
movq %rax, -0x320(%rbp)
jmp 0x1cc49
xorl %eax, %eax
movl %eax, %edi
callq 0x12530
subq 0xa2b96(%rip), %rax     # 0xbf7d8
movq %rax, -0x320(%rbp)
movq -0x2e8(%rbp), %r10
movq -0x2f0(%rbp), %r11
movq -0x2f8(%rbp), %r9
movl -0x2fc(%rbp), %r8d
movq -0x308(%rbp), %rcx
movl -0x30c(%rbp), %edx
movq -0x318(%rbp), %rdi
movq -0x320(%rbp), %rax
leaq 0x87970(%rip), %rsi     # 0xa45f7
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, 0xa2761(%rip)     # 0xbf408
je 0x1cd71
movq 0xa275c(%rip), %rax     # 0xbf410
subq 0xa275d(%rip), %rax     # 0xbf418
movq %rax, -0x238(%rbp)
cvtsi2sdq 0xa274d(%rip), %xmm0 # 0xbf418
cvtsi2sdq 0xa273c(%rip), %xmm1 # 0xbf410
divsd %xmm1, %xmm0
movsd 0x86780(%rip), %xmm1    # 0xa3460
mulsd %xmm1, %xmm0
movsd %xmm0, -0x220(%rbp)
movq 0xa2a3d(%rip), %rax     # 0xbf730
subq 0xa2726(%rip), %rax     # 0xbf420
movq %rax, -0x230(%rbp)
cmpq $0x0, -0x230(%rbp)
jne 0x1cd18
movq $0x1, -0x228(%rbp)
jmp 0x1cd37
movq -0x230(%rbp), %rax
imulq -0x238(%rbp), %rax
cqto
idivq 0xa26e8(%rip)           # 0xbf418
movq %rax, -0x228(%rbp)
movq -0x38(%rbp), %rdi
movq 0xa26de(%rip), %rdx     # 0xbf420
movq 0xa26c7(%rip), %rcx     # 0xbf410
movq 0xa26c8(%rip), %r8      # 0xbf418
movsd -0x220(%rbp), %xmm0
movq -0x228(%rbp), %r9
leaq 0x87963(%rip), %rsi     # 0xa46c9
movb $0x1, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
jmp 0x1cd73
cmpl $0x0, -0x17c(%rbp)
jne 0x1cd9e
cmpl $0x0, -0x180(%rbp)
jne 0x1cd9e
movq -0x30(%rbp), %rdi
leaq 0x87b41(%rip), %rsi     # 0xa48d1
callq 0x12070
cmpl $0x0, %eax
jne 0x1cebf
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1cdc8
movq -0x38(%rbp), %rdi
leaq 0x891a0(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x358(%rbp)
movq 0xa268e(%rip), %rax     # 0xbf468
movq %rax, -0x350(%rbp)
movq 0xa2678(%rip), %rax     # 0xbf460
movq %rax, -0x348(%rbp)
xorl %edi, %edi
callq 0x19630
movq %rax, -0x340(%rbp)
movq 0xa2694(%rip), %rax     # 0xbf498
movq %rax, -0x338(%rbp)
movq 0xa268e(%rip), %rax     # 0xbf4a0
movq %rax, -0x330(%rbp)
movl $0x1, %edi
callq 0x19630
cvtsi2ss %rax, %xmm0
movss 0x86670(%rip), %xmm1    # 0xa34a0
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x328(%rbp)
movl $0x2, %edi
callq 0x19630
movq -0x358(%rbp), %rdi
movq -0x350(%rbp), %rdx
movq -0x348(%rbp), %rcx
movq -0x340(%rbp), %r8
movq -0x338(%rbp), %r9
movq -0x330(%rbp), %r11
movsd -0x328(%rbp), %xmm0
cvtsi2ss %rax, %xmm1
movss 0x86617(%rip), %xmm2    # 0xa34a0
divss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
movq 0xa25f0(%rip), %r10     # 0xbf488
movq 0xa25d9(%rip), %rax     # 0xbf478
leaq 0x878a4(%rip), %rsi     # 0xa474a
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x2, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1ceea
cmpl $0x0, -0x180(%rbp)
jne 0x1ceea
movq -0x30(%rbp), %rdi
leaq 0x87982(%rip), %rsi     # 0xa485e
callq 0x12070
cmpl $0x0, %eax
jne 0x1cfc2
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1cf14
movq -0x38(%rbp), %rdi
leaq 0x89054(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
cvtsi2ssq -0xc8(%rbp), %xmm0
cvtsi2ssq -0xc0(%rbp), %xmm1
movss 0x86572(%rip), %xmm2    # 0xa34a4
divss %xmm2, %xmm1
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2ssq -0xd8(%rbp), %xmm1
cvtsi2ssq -0xd0(%rbp), %xmm2
movss 0x8654c(%rip), %xmm3    # 0xa34a4
divss %xmm3, %xmm2
addss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
cvtsi2ssq -0x158(%rbp), %xmm2
cvtsi2ssq -0x150(%rbp), %xmm3
movss 0x86526(%rip), %xmm4    # 0xa34a4
divss %xmm4, %xmm3
addss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
cvtsi2ssq -0x168(%rbp), %xmm3
cvtsi2ssq -0x160(%rbp), %xmm4
movss 0x86500(%rip), %xmm5    # 0xa34a4
divss %xmm5, %xmm4
addss %xmm4, %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x878ab(%rip), %rsi     # 0xa4862
movb $0x4, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x17c(%rbp)
jne 0x1cfe4
movq -0x30(%rbp), %rdi
leaq 0x878f4(%rip), %rsi     # 0xa48ca
callq 0x12070
cmpl $0x0, %eax
jne 0x1d135
movl -0x184(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x184(%rbp)
cmpl $0x0, %eax
je 0x1d00e
movq -0x38(%rbp), %rdi
leaq 0x88f5a(%rip), %rsi     # 0xa5f5f
callq 0x1ee70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x878be(%rip), %rsi     # 0xa48d7
movb $0x0, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
movl $0x1f, -0x48(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x1d133
movslq -0x44(%rbp), %rcx
leaq 0xa14d7(%rip), %rax     # 0xbe520
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1d06a
jmp 0x1d125
movq -0x38(%rbp), %rax
movq %rax, -0x378(%rbp)
movq -0x240(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x370(%rbp)
movq -0x240(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x368(%rbp)
movq -0x240(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x360(%rbp)
movq -0x240(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1d0c5
xorps %xmm0, %xmm0
movss %xmm0, -0x37c(%rbp)
jmp 0x1d0eb
movq -0x240(%rbp), %rax
cvtsi2ssq 0x30(%rax), %xmm0
movq -0x240(%rbp), %rax
cvtsi2ssq 0x38(%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x37c(%rbp)
movq -0x360(%rbp), %r8
movq -0x368(%rbp), %rcx
movq -0x370(%rbp), %rdx
movq -0x378(%rbp), %rdi
movss -0x37c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x877ce(%rip), %rsi     # 0xa48e8
movb $0x1, %al
callq 0x1f350
movq %rax, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1d032
jmp 0x1d135
movq -0x38(%rbp), %rax
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)