// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/latency.c
// Function: createLatencyReport
sds createLatencyReport(void) {
    sds report = sdsempty();
    int advise_better_vm = 0;       /* Better virtual machines. */
    int advise_slowlog_enabled = 0; /* Enable slowlog. */
    int advise_slowlog_tuning = 0;  /* Reconfigure slowlog. */
    int advise_slowlog_inspect = 0; /* Check your slowlog. */
    int advise_disk_contention = 0; /* Try to lower disk contention. */
    int advise_scheduler = 0;       /* Intrinsic latency. */
    int advise_data_writeback = 0;  /* data=writeback. */
    int advise_no_appendfsync = 0;  /* don't fsync during rewrites. */
    int advise_local_disk = 0;      /* Avoid remote disks. */
    int advise_ssd = 0;             /* Use an SSD drive. */
    int advise_write_load_info = 0; /* Print info about AOF and write load. */
    int advise_hz = 0;              /* Use higher HZ. */
    int advise_large_objects = 0;   /* Deletion of large objects. */
    int advise_mass_eviction = 0;   /* Avoid mass eviction of keys. */
    int advise_relax_fsync_policy = 0; /* appendfsync always is slow. */
    int advise_disable_thp = 0;     /* AnonHugePages detected. */
    int advices = 0;

    /* Return ASAP if the latency engine is disabled and it looks like it
     * was never enabled so far. */
    if (dictSize(server.latency_events) == 0 &&
        server.latency_monitor_threshold == 0)
    {
        report = sdscat(report,"I'm sorry, Dave, I can't do that. Latency monitoring is disabled in this Redis instance. You may use \"CONFIG SET latency-monitor-threshold <milliseconds>.\" in order to enable it. If we weren't in a deep space mission I'd suggest to take a look at http://redis.io/topics/latency-monitor.\n");
        return report;
    }

    /* Show all the events stats and add for each event some event-related
     * comment depending on the values. */
    dictIterator *di;
    dictEntry *de;
    int eventnum = 0;

    di = dictGetSafeIterator(server.latency_events);
    while((de = dictNext(di)) != NULL) {
        char *event = dictGetKey(de);
        struct latencyTimeSeries *ts = dictGetVal(de);
        struct latencyStats ls;

        if (ts == NULL) continue;
        eventnum++;
        if (eventnum == 1) {
            report = sdscat(report,"Dave, I have observed latency spikes in this Redis instance. You don't mind talking about it, do you Dave?\n\n");
        }
        analyzeLatencyForEvent(event,&ls);

        report = sdscatprintf(report,
            "%d. %s: %d latency spikes (average %lums, mean deviation %lums, period %.2f sec). Worst all time event %lums.",
            eventnum, event,
            ls.samples,
            (unsigned long) ls.avg,
            (unsigned long) ls.mad,
            (double) ls.period/ls.samples,
            (unsigned long) ts->max);

        /* Fork */
        if (!strcasecmp(event,"fork")) {
            char *fork_quality;
            if (server.stat_fork_rate < 10) {
                fork_quality = "terrible";
                advise_better_vm = 1;
                advices++;
            } else if (server.stat_fork_rate < 25) {
                fork_quality = "poor";
                advise_better_vm = 1;
                advices++;
            } else if (server.stat_fork_rate < 100) {
                fork_quality = "good";
            } else {
                fork_quality = "excellent";
            }
            report = sdscatprintf(report,
                " Fork rate is %.2f GB/sec (%s).", server.stat_fork_rate,
                fork_quality);
        }

        /* Potentially commands. */
        if (!strcasecmp(event,"command")) {
            if (server.slowlog_log_slower_than == 0) {
                advise_slowlog_enabled = 1;
                advices++;
            } else if (server.slowlog_log_slower_than/1000 >
                       server.latency_monitor_threshold)
            {
                advise_slowlog_tuning = 1;
                advices++;
            }
            advise_slowlog_inspect = 1;
            advise_large_objects = 1;
            advices += 2;
        }

        /* fast-command. */
        if (!strcasecmp(event,"fast-command")) {
            advise_scheduler = 1;
            advices++;
        }

        /* AOF and I/O. */
        if (!strcasecmp(event,"aof-write-pending-fsync")) {
            advise_local_disk = 1;
            advise_disk_contention = 1;
            advise_ssd = 1;
            advise_data_writeback = 1;
            advices += 4;
        }

        if (!strcasecmp(event,"aof-write-active-child")) {
            advise_no_appendfsync = 1;
            advise_data_writeback = 1;
            advise_ssd = 1;
            advices += 3;
        }

        if (!strcasecmp(event,"aof-write-alone")) {
            advise_local_disk = 1;
            advise_data_writeback = 1;
            advise_ssd = 1;
            advices += 3;
        }

        if (!strcasecmp(event,"aof-fsync-always")) {
            advise_relax_fsync_policy = 1;
            advices++;
        }

        if (!strcasecmp(event,"aof-fstat") ||
            !strcasecmp(event,"rdb-unlik-temp-file")) {
            advise_disk_contention = 1;
            advise_local_disk = 1;
            advices += 2;
        }

        if (!strcasecmp(event,"aof-rewrite-diff-write") ||
            !strcasecmp(event,"aof-rename")) {
            advise_write_load_info = 1;
            advise_data_writeback = 1;
            advise_ssd = 1;
            advise_local_disk = 1;
            advices += 4;
        }

        /* Expire cycle. */
        if (!strcasecmp(event,"expire-cycle")) {
            advise_hz = 1;
            advise_large_objects = 1;
            advices += 2;
        }

        /* Eviction cycle. */
        if (!strcasecmp(event,"eviction-del")) {
            advise_large_objects = 1;
            advices++;
        }

        if (!strcasecmp(event,"eviction-cycle")) {
            advise_mass_eviction = 1;
            advices++;
        }

        report = sdscatlen(report,"\n",1);
    }
    dictReleaseIterator(di);

    /* Add non event based advices. */
    if (THPGetAnonHugePagesSize() > 0) {
        advise_disable_thp = 1;
        advices++;
    }

    if (eventnum == 0 && advices == 0) {
        report = sdscat(report,"Dave, no latency spike was observed during the lifetime of this Redis instance, not in the slightest bit. I honestly think you ought to sit down calmly, take a stress pill, and think things over.\n");
    } else if (eventnum > 0 && advices == 0) {
        report = sdscat(report,"\nWhile there are latency events logged, I'm not able to suggest any easy fix. Please use the Redis community to get some help, providing this report in your help request.\n");
    } else {
        /* Add all the suggestions accumulated so far. */

        /* Better VM. */
        report = sdscat(report,"\nI have a few advices for you:\n\n");
        if (advise_better_vm) {
            report = sdscat(report,"- If you are using a virtual machine, consider upgrading it with a faster one using an hypervisior that provides less latency during fork() calls. Xen is known to have poor fork() performance. Even in the context of the same VM provider, certain kinds of instances can execute fork faster than others.\n");
        }

        /* Slow log. */
        if (advise_slowlog_enabled) {
            report = sdscatprintf(report,"- There are latency issues with potentially slow commands you are using. Try to enable the Slow Log Redis feature using the command 'CONFIG SET slowlog-log-slower-than %llu'. If the Slow log is disabled Redis is not able to log slow commands execution for you.\n", (unsigned long long)server.latency_monitor_threshold*1000);
        }

        if (advise_slowlog_tuning) {
            report = sdscatprintf(report,"- Your current Slow Log configuration only logs events that are slower than your configured latency monitor threshold. Please use 'CONFIG SET slowlog-log-slower-than %llu'.\n", (unsigned long long)server.latency_monitor_threshold*1000);
        }

        if (advise_slowlog_inspect) {
            report = sdscat(report,"- Check your Slow Log to understand what are the commands you are running which are too slow to execute. Please check http://redis.io/commands/slowlog for more information.\n");
        }

        /* Intrinsic latency. */
        if (advise_scheduler) {
            report = sdscat(report,"- The system is slow to execute Redis code paths not containing system calls. This usually means the system does not provide Redis CPU time to run for long periods. You should try to:\n"
            "  1) Lower the system load.\n"
            "  2) Use a computer / VM just for Redis if you are running other softawre in the same system.\n"
            "  3) Check if you have a \"noisy neighbour\" problem.\n"
            "  4) Check with 'redis-cli --intrinsic-latency 100' what is the intrinsic latency in your system.\n"
            "  5) Check if the problem is allocator-related by recompiling Redis with MALLOC=libc, if you are using Jemalloc. However this may create fragmentation problems.\n");
        }

        /* AOF / Disk latency. */
        if (advise_local_disk) {
            report = sdscat(report,"- It is strongly advised to use local disks for persistence, especially if you are using AOF. Remote disks provided by platform-as-a-service providers are known to be slow.\n");
        }

        if (advise_ssd) {
            report = sdscat(report,"- SSD disks are able to reduce fsync latency, and total time needed for snapshotting and AOF log rewriting (resulting in smaller memory usage and smaller final AOF rewrite buffer flushes). With extremely high write load SSD disks can be a good option. However Redis should perform reasonably with high load using normal disks. Use this advice as a last resort.\n");
        }

        if (advise_data_writeback) {
            report = sdscat(report,"- Mounting ext3/4 filesystems with data=writeback can provide a performance boost compared to data=ordered, however this mode of operation provides less guarantees, and sometimes it can happen that after a hard crash the AOF file will have an half-written command at the end and will require to be repaired before Redis restarts.\n");
        }

        if (advise_disk_contention) {
            report = sdscat(report,"- Try to lower the disk contention. This is often caused by other disk intensive processes running in the same computer (including other Redis instances).\n");
        }

        if (advise_no_appendfsync) {
            report = sdscat(report,"- Assuming from the point of view of data safety this is viable in your environment, you could try to enable the 'no-appendfsync-on-rewrite' option, so that fsync will not be performed while there is a child rewriting the AOF file or producing an RDB file (the moment where there is high disk contention).\n");
        }

        if (advise_relax_fsync_policy && server.aof_fsync == AOF_FSYNC_ALWAYS) {
            report = sdscat(report,"- Your fsync policy is set to 'always'. It is very hard to get good performances with such a setup, if possible try to relax the fsync policy to 'onesec'.\n");
        }

        if (advise_write_load_info) {
            report = sdscat(report,"- Latency during the AOF atomic rename operation or when the final difference is flushed to the AOF file at the end of the rewrite, sometimes is caused by very high write load, causing the AOF buffer to get very large. If possible try to send less commands to accomplish the same work, or use Lua scripts to group multiple operations into a single EVALSHA call.\n");
        }

        if (advise_hz && server.hz < 100) {
            report = sdscat(report,"- In order to make the Redis keys expiring process more incremental, try to set the 'hz' configuration parameter to 100 using 'CONFIG SET hz 100'.\n");
        }

        if (advise_large_objects) {
            report = sdscat(report,"- Deleting, expiring or evicting (because of maxmemory policy) large objects is a blocking operation. If you have very large objects that are often deleted, expired, or evicted, try to fragment those objects into multiple smaller objects.\n");
        }

        if (advise_mass_eviction) {
            report = sdscat(report,"- Sudden changes to the 'maxmemory' setting via 'CONFIG SET', or allocation of large objects via sets or sorted sets intersections, STORE option of SORT, Redis Cluster large keys migrations (RESTORE command), may create sudden memory pressure forcing the server to block trying to evict keys. \n");
        }

        if (advise_disable_thp) {
            report = sdscat(report,"- I detected a non zero amount of anonymous huge pages used by your process. This creates very serious latency events in different conditions, especially when Redis is persisting on disk. To disable THP support use the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled', make sure to also add it into /etc/rc.local so that the command will be executed again after a reboot. Note that even if you have already disabled THP, you still need to restart the Redis process to get rid of the huge pages already created.\n");
        }
    }

    return report;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
callq 0x384f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
leaq 0xd6a86(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rax
movq 0x28(%rax), %rax
leaq 0xd6a74(%rip), %rcx     # 0x1781d8
movq 0xa20(%rcx), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
jne 0xa17a7
leaq 0xd6a5c(%rip), %rax     # 0x1781d8
cmpq $0x0, 0xa18(%rax)
jne 0xa17a7
movq -0x10(%rbp), %rdi
leaq 0xa62be(%rip), %rsi     # 0x147a4f
callq 0x390d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1e82
movl $0x0, -0x6c(%rbp)
leaq 0xd6a23(%rip), %rax     # 0x1781d8
movq 0xa20(%rax), %rdi
callq 0x2e470
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xa1c10
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0xa17fc
jmp 0xa17c5
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x1, -0x6c(%rbp)
jne 0xa181f
movq -0x10(%rbp), %rdi
leaq 0xa6359(%rip), %rsi     # 0x147b6f
callq 0x390d0
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xa1420
movq -0x10(%rbp), %rdi
movl -0x6c(%rbp), %edx
movq -0x78(%rbp), %rcx
movl -0x8c(%rbp), %eax
movl %eax, %r8d
movl -0x9c(%rbp), %r9d
movl -0x90(%rbp), %esi
movl %esi, %r10d
cvtsi2sdq -0x88(%rbp), %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
leaq 0xa6369(%rip), %rsi     # 0x147bdc
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x1, %al
callq 0x395b0
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9baef(%rip), %rsi     # 0x13d381
callq 0x26300
cmpl $0x0, %eax
jne 0xa1979
movsd 0xa6140(%rip), %xmm0    # 0x1479e8
leaq 0xd6929(%rip), %rax     # 0x1781d8
ucomisd 0x3d0(%rax), %xmm0
jbe 0xa18d9
leaq 0xa638a(%rip), %rax     # 0x147c4a
movq %rax, -0xa8(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa194d
movsd 0xa610f(%rip), %xmm0    # 0x1479f0
leaq 0xd68f0(%rip), %rax     # 0x1781d8
ucomisd 0x3d0(%rax), %xmm0
jbe 0xa1912
leaq 0xa635a(%rip), %rax     # 0x147c53
movq %rax, -0xa8(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa194b
movsd 0x95b7e(%rip), %xmm0    # 0x137498
leaq 0xd68b7(%rip), %rax     # 0x1781d8
ucomisd 0x3d0(%rax), %xmm0
jbe 0xa193b
leaq 0xa6326(%rip), %rax     # 0x147c58
movq %rax, -0xa8(%rbp)
jmp 0xa1949
leaq 0xa631b(%rip), %rax     # 0x147c5d
movq %rax, -0xa8(%rbp)
jmp 0xa194b
jmp 0xa194d
movq -0x10(%rbp), %rdi
leaq 0xd6880(%rip), %rax     # 0x1781d8
movsd 0x3d0(%rax), %xmm0
movq -0xa8(%rbp), %rdx
leaq 0xa62f9(%rip), %rsi     # 0x147c67
movb $0x1, %al
callq 0x395b0
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x96c93(%rip), %rsi     # 0x138617
callq 0x26300
cmpl $0x0, %eax
jne 0xa1a02
leaq 0xd6843(%rip), %rax     # 0x1781d8
cmpq $0x0, 0x408(%rax)
jne 0xa19b1
movl $0x1, -0x18(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa19eb
leaq 0xd6820(%rip), %rax     # 0x1781d8
movq 0x408(%rax), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
leaq 0xd6808(%rip), %rcx     # 0x1781d8
cmpq 0xa18(%rcx), %rax
jle 0xa19e9
movl $0x1, -0x1c(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa19eb
movl $0x1, -0x20(%rbp)
movl $0x1, -0x44(%rbp)
movl -0x54(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x96bc0(%rip), %rsi     # 0x1385cd
callq 0x26300
cmpl $0x0, %eax
jne 0xa1a27
movl $0x1, -0x28(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9db93(%rip), %rsi     # 0x13f5c5
callq 0x26300
cmpl $0x0, %eax
jne 0xa1a61
movl $0x1, -0x34(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x1, -0x38(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x54(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9db71(%rip), %rsi     # 0x13f5dd
callq 0x26300
cmpl $0x0, %eax
jne 0xa1a94
movl $0x1, -0x30(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x1, -0x38(%rbp)
movl -0x54(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9db55(%rip), %rsi     # 0x13f5f4
callq 0x26300
cmpl $0x0, %eax
jne 0xa1ac7
movl $0x1, -0x34(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x1, -0x38(%rbp)
movl -0x54(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9dcb4(%rip), %rsi     # 0x13f786
callq 0x26300
cmpl $0x0, %eax
jne 0xa1aec
movl $0x1, -0x4c(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9e436(%rip), %rsi     # 0x13ff2d
callq 0x26300
cmpl $0x0, %eax
je 0xa1b16
movq -0x78(%rbp), %rdi
leaq 0xa617b(%rip), %rsi     # 0x147c87
callq 0x26300
cmpl $0x0, %eax
jne 0xa1b2d
movl $0x1, -0x24(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x54(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x9e4a8(%rip), %rsi     # 0x13ffe0
callq 0x26300
cmpl $0x0, %eax
je 0xa1b57
movq -0x78(%rbp), %rdi
leaq 0x9e530(%rip), %rsi     # 0x14007d
callq 0x26300
cmpl $0x0, %eax
jne 0xa1b7c
movl $0x1, -0x3c(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x1, -0x38(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x54(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x95e1c(%rip), %rsi     # 0x1379a3
callq 0x26300
cmpl $0x0, %eax
jne 0xa1ba8
movl $0x1, -0x40(%rbp)
movl $0x1, -0x44(%rbp)
movl -0x54(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x978dc(%rip), %rsi     # 0x13948f
callq 0x26300
cmpl $0x0, %eax
jne 0xa1bcd
movl $0x1, -0x44(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x978cc(%rip), %rsi     # 0x1394a4
callq 0x26300
cmpl $0x0, %eax
jne 0xa1bf2
movl $0x1, -0x48(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9823c(%rip), %rsi     # 0x139e39
movl $0x1, %edx
callq 0x39040
movq %rax, -0x10(%rbp)
jmp 0xa17c5
movq -0x60(%rbp), %rdi
callq 0x2e600
callq 0xa11c0
cmpl $0x0, %eax
jle 0xa1c33
movl $0x1, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x6c(%rbp)
jne 0xa1c58
cmpl $0x0, -0x54(%rbp)
jne 0xa1c58
movq -0x10(%rbp), %rdi
leaq 0xa6051(%rip), %rsi     # 0x147c9b
callq 0x390d0
movq %rax, -0x10(%rbp)
jmp 0xa1e7a
cmpl $0x0, -0x6c(%rbp)
jle 0xa1c7d
cmpl $0x0, -0x54(%rbp)
jne 0xa1c7d
movq -0x10(%rbp), %rdi
leaq 0xa60f1(%rip), %rsi     # 0x147d60
callq 0x390d0
movq %rax, -0x10(%rbp)
jmp 0xa1e78
movq -0x10(%rbp), %rdi
leaq 0xa6184(%rip), %rsi     # 0x147e0c
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa1cab
movq -0x10(%rbp), %rdi
leaq 0xa618b(%rip), %rsi     # 0x147e2d
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa1cd9
movq -0x10(%rbp), %rdi
leaq 0xd651c(%rip), %rax     # 0x1781d8
imulq $0x3e8, 0xa18(%rax), %rdx # imm = 0x3E8
leaq 0xa628e(%rip), %rsi     # 0x147f5c
movb $0x0, %al
callq 0x395b0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xa1d07
movq -0x10(%rbp), %rdi
leaq 0xd64ee(%rip), %rax     # 0x1781d8
imulq $0x3e8, 0xa18(%rax), %rdx # imm = 0x3E8
leaq 0xa6366(%rip), %rsi     # 0x148062
movb $0x0, %al
callq 0x395b0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xa1d21
movq -0x10(%rbp), %rdi
leaq 0xa63f8(%rip), %rsi     # 0x148110
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0xa1d3b
movq -0x10(%rbp), %rdi
leaq 0xa648c(%rip), %rsi     # 0x1481be
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xa1d55
movq -0x10(%rbp), %rdi
leaq 0xa66dc(%rip), %rsi     # 0x148428
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0xa1d6f
movq -0x10(%rbp), %rdi
leaq 0xa6770(%rip), %rsi     # 0x1484d6
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xa1d89
movq -0x10(%rbp), %rdi
leaq 0xa68c0(%rip), %rsi     # 0x148640
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xa1da3
movq -0x10(%rbp), %rdi
leaq 0xa69f1(%rip), %rsi     # 0x14878b
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xa1dbd
movq -0x10(%rbp), %rdi
leaq 0xa6a73(%rip), %rsi     # 0x148827
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xa1de7
leaq 0xd640e(%rip), %rax     # 0x1781d8
cmpl $0x1, 0x66c(%rax)
jne 0xa1de7
movq -0x10(%rbp), %rdi
leaq 0xa6b7c(%rip), %rsi     # 0x14895a
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xa1e01
movq -0x10(%rbp), %rdi
leaq 0xa6bfe(%rip), %rsi     # 0x1489f6
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0xa1e28
leaq 0xd63ca(%rip), %rax     # 0x1781d8
cmpl $0x64, 0x20(%rax)
jge 0xa1e28
movq -0x10(%rbp), %rdi
leaq 0xa6d42(%rip), %rsi     # 0x148b61
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xa1e42
movq -0x10(%rbp), %rdi
leaq 0xa6dbc(%rip), %rsi     # 0x148bf5
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xa1e5c
movq -0x10(%rbp), %rdi
leaq 0xa6e92(%rip), %rsi     # 0x148ce5
callq 0x390d0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x50(%rbp)
je 0xa1e76
movq -0x10(%rbp), %rdi
leaq 0xa6f9f(%rip), %rsi     # 0x148e0c
callq 0x390d0
movq %rax, -0x10(%rbp)
jmp 0xa1e78
jmp 0xa1e7a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop