// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
callq 0x3114c
movq %rax, %r13
leaq 0x87778(%rip), %rcx     # 0xf98a8
movq 0xa20(%rcx), %rdi
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
jne 0x72157
cmpq $0x0, 0xa18(%rcx)
jne 0x72157
leaq 0x4c6fd(%rip), %rsi     # 0xbe84f
jmp 0x725a0
callq 0x2a9c4
movq %rax, 0x40(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, %r15d
movl $0x0, (%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x0, 0x38(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x20(%rsp)
xorl %r12d, %r12d
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2a9d3
testq %rax, %rax
je 0x7255c
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x721e1
movq (%rax), %r14
cmpl $0x0, 0xc(%rsp)
je 0x7220c
movl %r15d, %ebp
jmp 0x72221
movl %r15d, %ebp
movq %r13, %rdi
leaq 0x4c756(%rip), %rsi     # 0xbe96f
callq 0x317b7
movq %rax, %r13
movl 0xc(%rsp), %r15d
incl %r15d
movq %r14, %rdi
leaq 0x48(%rsp), %rsi
callq 0x71fcf
movl 0x5c(%rsp), %r8d
movl 0x4c(%rsp), %r9d
movl 0x58(%rsp), %r10d
cvtsi2sdq 0x60(%rsp), %xmm0
cvtsi2sd %r8, %xmm1
divsd %xmm1, %xmm0
movl 0x4(%rbx), %r11d
movq %r13, %rdi
leaq 0x4c779(%rip), %rsi     # 0xbe9dc
movl %r15d, 0xc(%rsp)
movl %r15d, %edx
movq %r14, %rcx
movb $0x1, %al
pushq %r11
pushq %r10
callq 0x31a38
popq %rcx
popq %rdx
movq %rax, %rbx
movq %r14, %rdi
leaq 0x42026(%rip), %rsi     # 0xb42ae
callq 0x262f0
testl %eax, %eax
je 0x7229d
movl %ebp, %r15d
pushq $0x1
popq %r13
jmp 0x72323
leaq 0x87604(%rip), %rax     # 0xf98a8
movsd 0x3d0(%rax), %xmm0
movsd 0x4c534(%rip), %xmm1    # 0xbe7e8
ucomisd %xmm0, %xmm1
movl %ebp, %r15d
pushq $0x1
popq %r13
jbe 0x722d2
incl %r12d
movl %r13d, 0x14(%rsp)
leaq 0x4c77a(%rip), %rdx     # 0xbea4a
jmp 0x7230f
movsd 0x4c516(%rip), %xmm1    # 0xbe7f0
ucomisd %xmm0, %xmm1
jbe 0x722f1
incl %r12d
movl %r13d, 0x14(%rsp)
leaq 0x4c764(%rip), %rdx     # 0xbea53
jmp 0x7230f
movsd 0x3c14f(%rip), %xmm1    # 0xae448
ucomisd %xmm0, %xmm1
leaq 0x4c759(%rip), %rdx     # 0xbea5d
leaq 0x4c74d(%rip), %rax     # 0xbea58
cmovaq %rax, %rdx
movq %rbx, %rdi
leaq 0x4c74e(%rip), %rsi     # 0xbea67
movb $0x1, %al
callq 0x31a38
movq %rax, %rbx
movq %r14, %rdi
leaq 0x3d26a(%rip), %rsi     # 0xaf597
callq 0x262f0
testl %eax, %eax
je 0x7233b
movq %rbx, %rbp
jmp 0x7238e
leaq 0x87566(%rip), %rsi     # 0xf98a8
movq 0x408(%rsi), %rax
testq %rax, %rax
je 0x72372
cqto
movl $0x3e8, %ecx            # imm = 0x3E8
idivq %rcx
xorl %ecx, %ecx
cmpq 0xa18(%rsi), %rax
setg %cl
movl 0x18(%rsp), %eax
cmovgl %r13d, %eax
movl %eax, 0x18(%rsp)
jmp 0x7237a
movl %r13d, %ecx
movl %r13d, 0x2c(%rsp)
movq %rbx, %rbp
addl %ecx, %r12d
addl $0x2, %r12d
movl %r13d, 0x30(%rsp)
movl %r13d, 0x10(%rsp)
movq %r14, %rdi
leaq 0x3d1b5(%rip), %rsi     # 0xaf54d
callq 0x262f0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
cmovel %r13d, %r15d
addl %r12d, %ebx
movq %r14, %rdi
leaq 0x44100(%rip), %rsi     # 0xb64b5
callq 0x262f0
testl %eax, %eax
je 0x723c4
movl (%rsp), %r12d
jmp 0x723d9
addl $0x4, %ebx
movl %r13d, 0x1c(%rsp)
movl %r13d, %r12d
movl %r13d, 0x8(%rsp)
movl %r13d, 0x4(%rsp)
movq %r14, %rdi
leaq 0x440ea(%rip), %rsi     # 0xb64cd
callq 0x262f0
testl %eax, %eax
jne 0x723fc
addl $0x3, %ebx
movl %r13d, %r12d
movl %r13d, 0x34(%rsp)
movl %r13d, 0x4(%rsp)
movq %r14, %rdi
leaq 0x440de(%rip), %rsi     # 0xb64e4
callq 0x262f0
testl %eax, %eax
movl %r15d, 0x3c(%rsp)
jne 0x72424
addl $0x3, %ebx
movl %r13d, %r12d
movl %r13d, 0x8(%rsp)
movl %r13d, 0x4(%rsp)
movq %r14, %rdi
leaq 0x44248(%rip), %rsi     # 0xb6676
callq 0x262f0
xorl %r15d, %r15d
testl %eax, %eax
sete %r15b
movl 0x20(%rsp), %eax
cmovel %r13d, %eax
movl %eax, 0x20(%rsp)
addl %ebx, %r15d
movq %r14, %rdi
leaq 0x449c8(%rip), %rsi     # 0xb6e1d
callq 0x262f0
testl %eax, %eax
je 0x72471
movq %r14, %rdi
leaq 0x4c61f(%rip), %rsi     # 0xbea87
callq 0x262f0
testl %eax, %eax
jne 0x7247f
addl $0x2, %r15d
movl %r13d, 0x1c(%rsp)
movl %r13d, 0x8(%rsp)
movq %r14, %rdi
leaq 0x44a47(%rip), %rsi     # 0xb6ed0
callq 0x262f0
testl %eax, %eax
je 0x724ab
movq %r14, %rdi
leaq 0x44ad1(%rip), %rsi     # 0xb6f6d
callq 0x262f0
testl %eax, %eax
je 0x724ab
movl %r12d, (%rsp)
jmp 0x724c2
addl $0x4, %r15d
movl %r13d, (%rsp)
movl %r13d, 0x8(%rsp)
movl %r13d, 0x4(%rsp)
movl %r13d, 0x38(%rsp)
movq %r14, %rdi
leaq 0x3c457(%rip), %rsi     # 0xae923
callq 0x262f0
movl %eax, %r12d
leal 0x2(%r15), %ebx
movq %r14, %rdi
leaq 0x3df2d(%rip), %rsi     # 0xb040f
callq 0x262f0
testl %r12d, %r12d
movl 0x24(%rsp), %ecx
cmovel %r13d, %ecx
movl %ecx, 0x24(%rsp)
cmovnel %r15d, %ebx
movl 0x10(%rsp), %ecx
cmovel %r13d, %ecx
xorl %r15d, %r15d
testl %eax, %eax
sete %r15b
cmovel %r13d, %ecx
movl %ecx, 0x10(%rsp)
movq %r14, %rdi
leaq 0x3df07(%rip), %rsi     # 0xb0424
callq 0x262f0
xorl %r12d, %r12d
testl %eax, %eax
sete %r12b
movl 0x28(%rsp), %eax
cmovel %r13d, %eax
movl %eax, 0x28(%rsp)
addl %r15d, %r12d
addl %ebx, %r12d
movq %rbp, %rdi
leaq 0x3e872(%rip), %rsi     # 0xb0db9
pushq $0x1
popq %rdx
callq 0x31758
movq %rax, %r13
movl 0x3c(%rsp), %r15d
jmp 0x721e1
movq 0x40(%rsp), %rdi
callq 0x2aa94
callq 0x71e5a
movl %eax, %r14d
xorl %eax, %eax
testl %r14d, %r14d
setg %al
negl %eax
cmpl $0x0, 0xc(%rsp)
jne 0x7258d
cmpl %eax, %r12d
jne 0x7258d
leaq 0x4c510(%rip), %rsi     # 0xbea9b
jmp 0x725a0
cmpl $0x0, 0xc(%rsp)
jle 0x725b6
cmpl %eax, %r12d
jne 0x725b6
leaq 0x4c5c0(%rip), %rsi     # 0xbeb60
movq %r13, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x317b7
leaq 0x4c64f(%rip), %rsi     # 0xbec0c
movq %r13, %rdi
callq 0x317b7
cmpl $0x0, 0x14(%rsp)
je 0x725db
leaq 0x4c65a(%rip), %rsi     # 0xbec2d
movq %rax, %rdi
callq 0x317b7
leaq 0x872c6(%rip), %rcx     # 0xf98a8
movl (%rsp), %ebx
cmpl $0x0, 0x2c(%rsp)
je 0x72608
imulq $0x3e8, 0xa18(%rcx), %rdx # imm = 0x3E8
leaq 0x4c75e(%rip), %rsi     # 0xbed5c
movq %rax, %rdi
xorl %eax, %eax
callq 0x31a38
cmpl $0x0, 0x18(%rsp)
je 0x72632
leaq 0x87292(%rip), %rcx     # 0xf98a8
imulq $0x3e8, 0xa18(%rcx), %rdx # imm = 0x3E8
leaq 0x4c83a(%rip), %rsi     # 0xbee62
movq %rax, %rdi
xorl %eax, %eax
callq 0x31a38
cmpl $0x0, 0x30(%rsp)
je 0x72648
leaq 0x4c8d0(%rip), %rsi     # 0xbef10
movq %rax, %rdi
callq 0x317b7
testl %r15d, %r15d
je 0x7265c
leaq 0x4c96a(%rip), %rsi     # 0xbefbe
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x8(%rsp)
je 0x72672
leaq 0x4cbbe(%rip), %rsi     # 0xbf228
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x4(%rsp)
je 0x72688
leaq 0x4cc56(%rip), %rsi     # 0xbf2d6
movq %rax, %rdi
callq 0x317b7
testl %ebx, %ebx
je 0x7269b
leaq 0x4cdad(%rip), %rsi     # 0xbf440
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x1c(%rsp)
je 0x726b1
leaq 0x4cee2(%rip), %rsi     # 0xbf58b
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x34(%rsp)
je 0x726c7
leaq 0x4cf68(%rip), %rsi     # 0xbf627
movq %rax, %rdi
callq 0x317b7
leaq 0x871da(%rip), %rcx     # 0xf98a8
cmpl $0x0, 0x20(%rsp)
je 0x726ed
cmpl $0x1, 0x66c(%rcx)
jne 0x726ed
leaq 0x4d075(%rip), %rsi     # 0xbf75a
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x38(%rsp)
je 0x72703
leaq 0x4d0fb(%rip), %rsi     # 0xbf7f6
movq %rax, %rdi
callq 0x317b7
leaq 0x8719e(%rip), %rcx     # 0xf98a8
cmpl $0x0, 0x24(%rsp)
je 0x72726
cmpl $0x63, 0x20(%rcx)
jg 0x72726
leaq 0x4d243(%rip), %rsi     # 0xbf961
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x10(%rsp)
je 0x7273c
leaq 0x4d2c1(%rip), %rsi     # 0xbf9f5
movq %rax, %rdi
callq 0x317b7
cmpl $0x0, 0x28(%rsp)
je 0x72752
leaq 0x4d39b(%rip), %rsi     # 0xbfae5
movq %rax, %rdi
callq 0x317b7
testl %r14d, %r14d
jle 0x72766
leaq 0x4d4ae(%rip), %rsi     # 0xbfc0c
movq %rax, %rdi
jmp 0x725a3
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq