// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/debug.c
// Function: debugCommand
void debugCommand(client *c) {
    if (c->argc == 1) {
        addReplyError(c,"You must specify a subcommand for DEBUG. Try DEBUG HELP for info.");
        return;
    }

    if (!strcasecmp(c->argv[1]->ptr,"help")) {
        void *blenp = addDeferredMultiBulkLength(c);
        int blen = 0;
        blen++; addReplyStatus(c,
        "DEBUG <subcommand> arg arg ... arg. Subcommands:");
        blen++; addReplyStatus(c,
        "segfault -- Crash the server with sigsegv.");
        blen++; addReplyStatus(c,
        "restart  -- Graceful restart: save config, db, restart.");
        blen++; addReplyStatus(c,
        "crash-and-recovery <milliseconds> -- Hard crash and restart after <milliseconds> delay.");
        blen++; addReplyStatus(c,
        "assert   -- Crash by assertion failed.");
        blen++; addReplyStatus(c,
        "reload   -- Save the RDB on disk and reload it back in memory.");
        blen++; addReplyStatus(c,
        "loadaof  -- Flush the AOF buffers on disk and reload the AOF in memory.");
        blen++; addReplyStatus(c,
        "object <key> -- Show low level info about key and associated value.");
        blen++; addReplyStatus(c,
        "sdslen <key> -- Show low level SDS string info representing key and value.");
        blen++; addReplyStatus(c,
        "populate <count> [prefix] -- Create <count> string keys named key:<num>. If a prefix is specified is used instead of the 'key' prefix.");
        blen++; addReplyStatus(c,
        "digest   -- Outputs an hex signature representing the current DB content.");
        blen++; addReplyStatus(c,
        "sleep <seconds> -- Stop the server for <seconds>. Decimals allowed.");
        blen++; addReplyStatus(c,
        "set-active-expire (0|1) -- Setting it to 0 disables expiring keys in background when they are not accessed (otherwise the Redis behavior). Setting it to 1 reenables back the default.");
        blen++; addReplyStatus(c,
        "lua-always-replicate-commands (0|1) -- Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.");
        blen++; addReplyStatus(c,
        "error <string> -- Return a Redis protocol error with <string> as message. Useful for clients unit tests to simulate Redis errors.");
        blen++; addReplyStatus(c,
        "structsize -- Return the size of different Redis core C structures.");
        blen++; addReplyStatus(c,
        "htstats <dbid> -- Return hash table statistics of the specified Redis database.");
        blen++; addReplyStatus(c,
        "jemalloc info  -- Show internal jemalloc statistics.");
        blen++; addReplyStatus(c,
        "jemalloc purge -- Force jemalloc to release unused memory.");
        setDeferredMultiBulkLength(c,blenp,blen);
    } else if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
        *((char*)-1) = 'x';
    } else if (!strcasecmp(c->argv[1]->ptr,"restart") ||
               !strcasecmp(c->argv[1]->ptr,"crash-and-recover"))
    {
        long long delay = 0;
        if (c->argc >= 3) {
            if (getLongLongFromObjectOrReply(c, c->argv[2], &delay, NULL)
                != C_OK) return;
            if (delay < 0) delay = 0;
        }
        int flags = !strcasecmp(c->argv[1]->ptr,"restart") ?
            (RESTART_SERVER_GRACEFULLY|RESTART_SERVER_CONFIG_REWRITE) :
             RESTART_SERVER_NONE;
        restartServer(flags,delay);
        addReplyError(c,"failed to restart the server. Check server logs.");
    } else if (!strcasecmp(c->argv[1]->ptr,"oom")) {
        void *ptr = zmalloc(ULONG_MAX); /* Should trigger an out of memory. */
        zfree(ptr);
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"assert")) {
        if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]);
        serverAssertWithInfo(c,c->argv[0],1 == 2);
    } else if (!strcasecmp(c->argv[1]->ptr,"reload")) {
        if (rdbSave(server.rdb_filename) != C_OK) {
            addReply(c,shared.err);
            return;
        }
        emptyDb(NULL);
        if (rdbLoad(server.rdb_filename) != C_OK) {
            addReplyError(c,"Error trying to load the RDB dump");
            return;
        }
        serverLog(LL_WARNING,"DB reloaded by DEBUG RELOAD");
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
        if (server.aof_state == AOF_ON) flushAppendOnlyFile(1);
        emptyDb(NULL);
        if (loadAppendOnlyFile(server.aof_filename) != C_OK) {
            addReply(c,shared.err);
            return;
        }
        server.dirty = 0; /* Prevent AOF / replication */
        serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) {
        dictEntry *de;
        robj *val;
        char *strenc;

        if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
            addReply(c,shared.nokeyerr);
            return;
        }
        val = dictGetVal(de);
        strenc = strEncoding(val->encoding);

        char extra[128] = {0};
        if (val->encoding == OBJ_ENCODING_QUICKLIST) {
            char *nextra = extra;
            int remaining = sizeof(extra);
            quicklist *ql = val->ptr;
            /* Add number of quicklist nodes */
            int used = snprintf(nextra, remaining, " ql_nodes:%u", ql->len);
            nextra += used;
            remaining -= used;
            /* Add average quicklist fill factor */
            double avg = (double)ql->count/ql->len;
            used = snprintf(nextra, remaining, " ql_avg_node:%.2f", avg);
            nextra += used;
            remaining -= used;
            /* Add quicklist fill level / max ziplist size */
            used = snprintf(nextra, remaining, " ql_ziplist_max:%d", ql->fill);
            nextra += used;
            remaining -= used;
            /* Add isCompressed? */
            int compressed = ql->compress != 0;
            used = snprintf(nextra, remaining, " ql_compressed:%d", compressed);
            nextra += used;
            remaining -= used;
            /* Add total uncompressed size */
            unsigned long sz = 0;
            for (quicklistNode *node = ql->head; node; node = node->next) {
                sz += node->sz;
            }
            used = snprintf(nextra, remaining, " ql_uncompressed_size:%lu", sz);
            nextra += used;
            remaining -= used;
        }

        addReplyStatusFormat(c,
            "Value at:%p refcount:%d "
            "encoding:%s serializedlength:%zu "
            "lru:%d lru_seconds_idle:%llu%s",
            (void*)val, val->refcount,
            strenc, rdbSavedObjectLen(val),
            val->lru, estimateObjectIdleTime(val)/1000, extra);
    } else if (!strcasecmp(c->argv[1]->ptr,"sdslen") && c->argc == 3) {
        dictEntry *de;
        robj *val;
        sds key;

        if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
            addReply(c,shared.nokeyerr);
            return;
        }
        val = dictGetVal(de);
        key = dictGetKey(de);

        if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {
            addReplyError(c,"Not an sds encoded string.");
        } else {
            addReplyStatusFormat(c,
                "key_sds_len:%lld, key_sds_avail:%lld, "
                "val_sds_len:%lld, val_sds_avail:%lld",
                (long long) sdslen(key),
                (long long) sdsavail(key),
                (long long) sdslen(val->ptr),
                (long long) sdsavail(val->ptr));
        }
    } else if (!strcasecmp(c->argv[1]->ptr,"populate") &&
               (c->argc == 3 || c->argc == 4)) {
        long keys, j;
        robj *key, *val;
        char buf[128];

        if (getLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)
            return;
        dictExpand(c->db->dict,keys);
        for (j = 0; j < keys; j++) {
            snprintf(buf,sizeof(buf),"%s:%lu",
                (c->argc == 3) ? "key" : (char*)c->argv[3]->ptr, j);
            key = createStringObject(buf,strlen(buf));
            if (lookupKeyWrite(c->db,key) != NULL) {
                decrRefCount(key);
                continue;
            }
            snprintf(buf,sizeof(buf),"value:%lu",j);
            val = createStringObject(buf,strlen(buf));
            dbAdd(c->db,key,val);
            signalModifiedKey(c->db,key);
            decrRefCount(key);
        }
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"digest") && c->argc == 2) {
        unsigned char digest[20];
        sds d = sdsempty();
        int j;

        computeDatasetDigest(digest);
        for (j = 0; j < 20; j++)
            d = sdscatprintf(d, "%02x",digest[j]);
        addReplyStatus(c,d);
        sdsfree(d);
    } else if (!strcasecmp(c->argv[1]->ptr,"sleep") && c->argc == 3) {
        double dtime = strtod(c->argv[2]->ptr,NULL);
        long long utime = dtime*1000000;
        struct timespec tv;

        tv.tv_sec = utime / 1000000;
        tv.tv_nsec = (utime % 1000000) * 1000;
        nanosleep(&tv, NULL);
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"set-active-expire") &&
               c->argc == 3)
    {
        server.active_expire_enabled = atoi(c->argv[2]->ptr);
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"lua-always-replicate-commands") &&
               c->argc == 3)
    {
        server.lua_always_replicate_commands = atoi(c->argv[2]->ptr);
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"error") && c->argc == 3) {
        sds errstr = sdsnewlen("-",1);

        errstr = sdscatsds(errstr,c->argv[2]->ptr);
        errstr = sdsmapchars(errstr,"\n\r","  ",2); /* no newlines in errors. */
        errstr = sdscatlen(errstr,"\r\n",2);
        addReplySds(c,errstr);
    } else if (!strcasecmp(c->argv[1]->ptr,"structsize") && c->argc == 2) {
        sds sizes = sdsempty();
        sizes = sdscatprintf(sizes,"bits:%d ",(sizeof(void*) == 8)?64:32);
        sizes = sdscatprintf(sizes,"robj:%d ",(int)sizeof(robj));
        sizes = sdscatprintf(sizes,"dictentry:%d ",(int)sizeof(dictEntry));
        sizes = sdscatprintf(sizes,"sdshdr5:%d ",(int)sizeof(struct sdshdr5));
        sizes = sdscatprintf(sizes,"sdshdr8:%d ",(int)sizeof(struct sdshdr8));
        sizes = sdscatprintf(sizes,"sdshdr16:%d ",(int)sizeof(struct sdshdr16));
        sizes = sdscatprintf(sizes,"sdshdr32:%d ",(int)sizeof(struct sdshdr32));
        sizes = sdscatprintf(sizes,"sdshdr64:%d ",(int)sizeof(struct sdshdr64));
        addReplyBulkSds(c,sizes);
    } else if (!strcasecmp(c->argv[1]->ptr,"htstats") && c->argc == 3) {
        long dbid;
        sds stats = sdsempty();
        char buf[4096];

        if (getLongFromObjectOrReply(c, c->argv[2], &dbid, NULL) != C_OK)
            return;
        if (dbid < 0 || dbid >= server.dbnum) {
            addReplyError(c,"Out of range database");
            return;
        }

        stats = sdscatprintf(stats,"[Dictionary HT]\n");
        dictGetStats(buf,sizeof(buf),server.db[dbid].dict);
        stats = sdscat(stats,buf);

        stats = sdscatprintf(stats,"[Expires HT]\n");
        dictGetStats(buf,sizeof(buf),server.db[dbid].expires);
        stats = sdscat(stats,buf);

        addReplyBulkSds(c,stats);
    } else if (!strcasecmp(c->argv[1]->ptr,"jemalloc") && c->argc == 3) {
#if defined(USE_JEMALLOC)
        if (!strcasecmp(c->argv[2]->ptr, "info")) {
            sds info = sdsempty();
            je_malloc_stats_print(inputCatSds, &info, NULL);
            addReplyBulkSds(c, info);
        } else if (!strcasecmp(c->argv[2]->ptr, "purge")) {
            char tmp[32];
            unsigned narenas = 0;
            size_t sz = sizeof(unsigned);
            if (!je_mallctl("arenas.narenas", &narenas, &sz, NULL, 0)) {
                sprintf(tmp, "arena.%d.purge", narenas);
                if (!je_mallctl(tmp, NULL, 0, NULL, 0)) {
                    addReply(c, shared.ok);
                    return;
                }
            }
            addReplyError(c, "Error purging dirty pages");
        } else {
            addReplyErrorFormat(c, "Valid jemalloc debug fields: info, purge");
        }
#else
        addReplyErrorFormat(c, "jemalloc support not available");
#endif
    } else {
        addReplyErrorFormat(c, "Unknown DEBUG subcommand or wrong number of arguments for '%s'",
            (char*)c->argv[1]->ptr);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
movl 0x38(%rdi), %r12d
cmpl $0x1, %r12d
jne 0x61abd
leaq 0x644eb(%rip), %rsi     # 0xc5f8f
movq %rbx, %rdi
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cc06
movq 0x40(%rbx), %r15
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
leaq 0x5d697(%rip), %rsi     # 0xbf167
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61d97
leaq 0x64b16(%rip), %rsi     # 0xc65fd
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61f57
leaq 0x64b08(%rip), %rsi     # 0xc6606
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61ee0
leaq 0x64af9(%rip), %rsi     # 0xc660e
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61ee0
leaq 0x5bdb7(%rip), %rsi     # 0xbd8e3
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61f71
leaq 0x64b0e(%rip), %rsi     # 0xc6651
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x6277f
leaq 0x64b05(%rip), %rsi     # 0xc665f
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61f95
leaq 0x64b33(%rip), %rsi     # 0xc66a4
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x61fd3
leaq 0x6f499(%rip), %rsi     # 0xd1021
movq %r14, %rdi
callq 0x262f0
cmpl $0x3, %r12d
jne 0x62016
testl %eax, %eax
jne 0x62016
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x2ebca
testq %rax, %rax
je 0x62065
movq 0x8(%rax), %r14
movl (%r14), %edi
shrl $0x4, %edi
andl $0xf, %edi
callq 0x41745
movq %rax, %r13
xorpd %xmm0, %xmm0
movapd %xmm0, 0x90(%rsp)
movapd %xmm0, 0x80(%rsp)
movapd %xmm0, 0x70(%rsp)
movapd %xmm0, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x20(%rsp)
movl $0xf0, %eax
andl (%r14), %eax
cmpl $0x90, %eax
jne 0x61d2d
movq %r13, 0x18(%rsp)
movq 0x8(%r14), %r15
movl 0x18(%r15), %ecx
leaq 0x64aa0(%rip), %rdx     # 0xc66d5
xorl %r12d, %r12d
leaq 0x20(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0x26120
cltq
leaq (%rsp,%rax), %r13
addq $0x20, %r13
movl $0x80, %ecx
subl %eax, %ecx
movsd 0x10(%r15), %xmm1
unpcklps 0x60cf9(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x60d01(%rip), %xmm1    # 0xc2970
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movl 0x18(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movslq %ecx, %rbp
leaq 0x64a4d(%rip), %rdx     # 0xc66e2
movq %r13, %rdi
movq %rbp, %rsi
movb $0x1, %al
callq 0x26120
cltq
addq %rax, %r13
subl %eax, %ebp
movslq %ebp, %rbp
movswl 0x1c(%r15), %ecx
leaq 0x64a3c(%rip), %rdx     # 0xc66f4
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x26120
cltq
addq %rax, %r13
subl %eax, %ebp
xorl %ecx, %ecx
cmpl $0x10000, 0x1c(%r15)    # imm = 0x10000
setae %cl
movslq %ebp, %rbp
leaq 0x64a24(%rip), %rdx     # 0xc6707
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x26120
cltq
addq %rax, %r13
subl %eax, %ebp
movq (%r15), %rax
testq %rax, %rax
je 0x61d11
xorl %r12d, %r12d
movl 0x18(%rax), %ecx
addq %rcx, %r12
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x61d02
movslq %ebp, %rsi
leaq 0x649fe(%rip), %rdx     # 0xc6719
movq %r13, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x26120
movq 0x18(%rsp), %r13
movl 0x4(%r14), %ebp
movq %r14, %rdi
callq 0x48e7e
movq %rax, %r12
movl (%r14), %r15d
shrl $0x8, %r15d
movq %r14, %rdi
callq 0x41760
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
movq %rdx, %r10
shrq $0x4, %r10
subq $0x8, %rsp
leaq 0x28(%rsp), %r11
leaq 0x649c0(%rip), %rsi     # 0xc6733
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %r13, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r15
callq 0x3cdf2
addq $0x20, %rsp
jmp 0x61f5f
movq %rbx, %rdi
callq 0x3cee9
movq %rax, %r14
leaq 0x64228(%rip), %rsi     # 0xc5fd1
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6424a(%rip), %rsi     # 0xc6002
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x64266(%rip), %rsi     # 0xc602d
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6428f(%rip), %rsi     # 0xc6065
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x642d8(%rip), %rsi     # 0xc60bd
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x642f0(%rip), %rsi     # 0xc60e4
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x64320(%rip), %rsi     # 0xc6123
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x64359(%rip), %rsi     # 0xc616b
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6438e(%rip), %rsi     # 0xc61af
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x643ca(%rip), %rsi     # 0xc61fa
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x64442(%rip), %rsi     # 0xc6281
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6447d(%rip), %rsi     # 0xc62cb
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x644b2(%rip), %rsi     # 0xc630f
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6455a(%rip), %rsi     # 0xc63c6
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x645fc(%rip), %rsi     # 0xc6477
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6466f(%rip), %rsi     # 0xc64f9
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x646a4(%rip), %rsi     # 0xc653d
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x646e5(%rip), %rsi     # 0xc658d
movq %rbx, %rdi
callq 0x3cdcb
leaq 0x6470b(%rip), %rsi     # 0xc65c2
movq %rbx, %rdi
callq 0x3cdcb
movl $0x13, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cf25
movq $0x0, 0x20(%rsp)
cmpl $0x3, %r12d
jl 0x61f19
movq 0x10(%r15), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x416bb
testl %eax, %eax
jne 0x61f5f
movq 0x20(%rsp), %r14
testq %r14, %r14
jns 0x61f1c
movq $0x0, 0x20(%rsp)
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x646d7(%rip), %rsi     # 0xc6606
callq 0x262f0
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %edi
movq %r14, %rsi
callq 0x320c5
leaq 0x646d3(%rip), %rsi     # 0xc6620
movq %rbx, %rdi
callq 0x3cc06
jmp 0x61f5f
movb $0x78, -0x1
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x1, %rdi
callq 0x382d1
movq %rax, %rdi
callq 0x38413
leaq 0xa0384(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
jmp 0x62070
leaq 0x9f90c(%rip), %r14     # 0x1018a8
movq 0x748(%r14), %rdi
callq 0x49593
testl %eax, %eax
jne 0x62009
xorl %edi, %edi
callq 0x41fe5
movq 0x748(%r14), %rdi
callq 0x4a3f2
testl %eax, %eax
je 0x621c3
leaq 0x64698(%rip), %rsi     # 0xc6666
jmp 0x61aa4
leaq 0x9f8ce(%rip), %r14     # 0x1018a8
cmpl $0x1, 0x668(%r14)
jne 0x61fee
movl $0x1, %edi
callq 0x5d159
xorl %edi, %edi
callq 0x41fe5
movq 0x670(%r14), %rdi
callq 0x5e15d
testl %eax, %eax
je 0x621af
leaq 0xa0300(%rip), %rax     # 0x102310
movq 0x10(%rax), %rsi
jmp 0x62070
leaq 0x6476e(%rip), %rsi     # 0xc678b
movq %r14, %rdi
callq 0x262f0
cmpl $0x3, %r12d
jne 0x62089
testl %eax, %eax
jne 0x62089
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x2ebca
testq %rax, %rax
je 0x62065
movq 0x8(%rax), %r12
movl (%r12), %ecx
testb $0xf, %cl
je 0x6229e
leaq 0x64732(%rip), %rsi     # 0xc6792
jmp 0x61aa4
leaq 0xa02a4(%rip), %rax     # 0x102310
movq 0x78(%rax), %rsi
movq %rbx, %rdi
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c854
leaq 0x64768(%rip), %rsi     # 0xc67f8
movq %r14, %rdi
callq 0x262f0
leal -0x3(%r12), %ecx
cmpl $0x1, %ecx
ja 0x621db
testl %eax, %eax
jne 0x621db
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x41718
testl %eax, %eax
jne 0x61f5f
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2e6fa
cmpq $0x0, 0x8(%rsp)
jle 0x62371
leaq 0x6d22a(%rip), %r12     # 0xcf317
leaq 0x6470d(%rip), %r14     # 0xc6801
leaq 0x20(%rsp), %r15
xorl %r13d, %r13d
cmpl $0x3, 0x38(%rbx)
movq %r12, %rcx
je 0x62111
movq 0x40(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rcx
movl $0x80, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %r13, %r8
xorl %eax, %eax
callq 0x26120
movq %r15, %rdi
callq 0x26500
movq %r15, %rdi
movq %rax, %rsi
callq 0x40744
movq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x41ad6
testq %rax, %rax
jne 0x62194
movl $0x80, %esi
movq %r15, %rdi
leaq 0x646ac(%rip), %rdx     # 0xc6808
movq %r13, %rcx
xorl %eax, %eax
callq 0x26120
movq %r15, %rdi
callq 0x26500
movq %r15, %rdi
movq %rax, %rsi
callq 0x40744
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x41b77
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x41d90
movq %rbp, %rdi
callq 0x40c8f
incq %r13
cmpq 0x8(%rsp), %r13
jl 0x620fc
jmp 0x62371
movq $0x0, 0x720(%r14)
leaq 0x644eb(%rip), %rsi     # 0xc66ac
jmp 0x621ca
leaq 0x644be(%rip), %rsi     # 0xc6688
movl $0x3, %edi
xorl %eax, %eax
callq 0x2fdad
jmp 0x61f85
leaq 0x64630(%rip), %rsi     # 0xc6812
movq %r14, %rdi
callq 0x262f0
cmpl $0x2, %r12d
jne 0x62247
testl %eax, %eax
jne 0x62247
callq 0x3628d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x61300
leaq 0x5d85d(%rip), %r15     # 0xbfa6a
xorl %r12d, %r12d
movzbl 0x20(%rsp,%r12), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x36f2d
movq %rax, %r14
incq %r12
cmpq $0x14, %r12
jne 0x62210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cdcb
movq %r14, %rdi
callq 0x36330
jmp 0x61f5f
leaq 0x645cb(%rip), %rsi     # 0xc6819
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x62309
leaq 0x645ba(%rip), %rsi     # 0xc681f
movq %r14, %rdi
callq 0x262f0
cmpl $0x3, %r12d
jne 0x62389
testl %eax, %eax
jne 0x62389
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x26760
leaq 0x9f615(%rip), %rcx     # 0x1018a8
movl %eax, 0x604(%rcx)
jmp 0x61f85
shrl $0x4, %ecx
testb $0x7, %cl
jne 0x62059
movq (%rax), %r14
movq %r14, %rdi
callq 0x61220
movq %rax, %r15
movq %r14, %rdi
callq 0x62806
movq %rax, %r14
movq 0x8(%r12), %r12
movq %r12, %rdi
callq 0x61220
movq %rax, %r13
movq %r12, %rdi
callq 0x62806
leaq 0x644cb(%rip), %rsi     # 0xc67ad
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cdf2
cmpl $0x3, %r12d
jne 0x62456
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x26cc0
mulsd 0x60656(%rip), %xmm0    # 0xc2980
cvttsd2si %xmm0, %rcx
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, (%rdi)
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
subq %rax, %rcx
imulq $0x3e8, %rcx, %rax      # imm = 0x3E8
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x26950
leaq 0x9ff98(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
jmp 0x61f5f
leaq 0x644a1(%rip), %rsi     # 0xc6831
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x62431
leaq 0x60a54(%rip), %rsi     # 0xc2dfb
movq %r14, %rdi
callq 0x262f0
cmpl $0x3, %r12d
jne 0x62456
testl %eax, %eax
jne 0x62456
leaq 0x6f15e(%rip), %rdi     # 0xd1526
movl $0x1, %esi
callq 0x36178
movq 0x40(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x36bc3
leaq 0x64462(%rip), %rsi     # 0xc684f
leaq 0x68367(%rip), %rdx     # 0xca75b
movl $0x2, %ecx
movq %rax, %rdi
callq 0x3812f
leaq 0x619d4(%rip), %rsi     # 0xc3ddc
movl $0x2, %edx
movq %rax, %rdi
callq 0x36ad1
movq %rbx, %rdi
movq %rax, %rsi
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ca86
cmpl $0x3, %r12d
jne 0x62456
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x26760
leaq 0x9f45d(%rip), %rcx     # 0x1018a8
movl %eax, 0xa14(%rcx)
jmp 0x61f85
leaq 0x643f5(%rip), %rsi     # 0xc6852
movq %r14, %rdi
callq 0x262f0
cmpl $0x2, %r12d
jne 0x62548
testl %eax, %eax
jne 0x62548
callq 0x3628d
leaq 0x643da(%rip), %rsi     # 0xc685d
movq %rax, %rdi
movl $0x40, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x643cd(%rip), %rsi     # 0xc6866
movq %rax, %rdi
movl $0x10, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x643c0(%rip), %rsi     # 0xc686f
movq %rax, %rdi
movl $0x18, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x643b8(%rip), %rsi     # 0xc687d
movq %rax, %rdi
movl $0x1, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x643ae(%rip), %rsi     # 0xc6889
movq %rax, %rdi
movl $0x3, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x643a4(%rip), %rsi     # 0xc6895
movq %rax, %rdi
movl $0x5, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x6439b(%rip), %rsi     # 0xc68a2
movq %rax, %rdi
movl $0x9, %edx
xorl %eax, %eax
callq 0x36f2d
leaq 0x64392(%rip), %rsi     # 0xc68af
movq %rax, %rdi
movl $0x11, %edx
xorl %eax, %eax
callq 0x36f2d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d386
leaq 0x6436d(%rip), %rsi     # 0xc68bc
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x625d4
leaq 0x64397(%rip), %rsi     # 0xc68f9
movq %r14, %rdi
callq 0x262f0
cmpl $0x3, %r12d
jne 0x626b5
testl %eax, %eax
jne 0x626b5
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
leaq 0x6e8e9(%rip), %rsi     # 0xd0e74
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x626da
leaq 0x643bb(%rip), %rsi     # 0xc695d
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
je 0x62708
leaq 0x64381(%rip), %rsi     # 0xc693a
movq %rbx, %rdi
xorl %eax, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cc2d
cmpl $0x3, %r12d
jne 0x626b5
callq 0x3628d
movq %rax, %r14
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x41718
testl %eax, %eax
jne 0x61f5f
movq 0x8(%rsp), %rax
testq %rax, %rax
js 0x62773
leaq 0x9f28e(%rip), %r12     # 0x1018a8
movslq 0x610(%r12), %rcx
cmpq %rcx, %rax
jge 0x62773
leaq 0x642a8(%rip), %rsi     # 0xc68da
movq %r14, %rdi
xorl %eax, %eax
callq 0x36f2d
movq %rax, %r15
movq 0x28(%r12), %rax
movq 0x8(%rsp), %rcx
shlq $0x6, %rcx
movq (%rax,%rcx), %rdx
leaq 0x20(%rsp), %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x2f7d8
movq %r15, %rdi
movq %r14, %rsi
callq 0x36b9c
leaq 0x64276(%rip), %rsi     # 0xc68eb
movq %rax, %rdi
xorl %eax, %eax
callq 0x36f2d
movq %rax, %r15
movq 0x28(%r12), %rax
movq 0x8(%rsp), %rcx
shlq $0x6, %rcx
movq 0x8(%rax,%rcx), %rdx
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x2f7d8
movq %r15, %rdi
movq %r14, %rsi
callq 0x36b9c
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x626fe
leaq 0x642a7(%rip), %rsi     # 0xc6963
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cc2d
callq 0x3628d
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq -0xc80(%rip), %rdi      # 0x61a6e
movq %r14, %rsi
xorl %edx, %edx
callq 0xa28db
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d386
jmp 0x61f5f
leaq 0x14(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x8(%rsp), %rdx
movq $0x4, (%rdx)
leaq 0x641dc(%rip), %rdi     # 0xc6902
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa27ac
testl %eax, %eax
jne 0x62767
movl 0x14(%rsp), %edx
leaq 0x641d2(%rip), %rsi     # 0xc6911
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x26580
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa27ac
testl %eax, %eax
je 0x62371
leaq 0x641b2(%rip), %rsi     # 0xc6920
jmp 0x61f4d
leaq 0x6414a(%rip), %rsi     # 0xc68c4
jmp 0x61f4d
cmpl $0x3, %r12d
jl 0x6279a
movq 0x10(%r15), %rdi
callq 0x40e09
movq 0x40(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x40(%rbx), %r15
movq (%r15), %rsi
leaq 0x63eb4(%rip), %rdx     # 0xc6658
leaq 0x637d1(%rip), %rcx     # 0xc5f7c
movq %rbx, %rdi
movl $0x14f, %r8d            # imm = 0x14F
callq 0x627c3
movl $0x1, %edi
callq 0x263c0