// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1310, %rsp           # imm = 0x1310
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x76e8e
movq -0x8(%rbp), %rdi
leaq 0xc9433(%rip), %rsi     # 0x1402b7
callq 0x42f90
jmp 0x7834d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc3238(%rip), %rsi     # 0x13a0dd
callq 0x26300
cmpl $0x0, %eax
jne 0x770b8
movq -0x8(%rbp), %rdi
callq 0x432a0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc941e(%rip), %rsi     # 0x1402f9
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9436(%rip), %rsi     # 0x14032a
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9448(%rip), %rsi     # 0x140355
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9467(%rip), %rsi     # 0x14038d
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc94a6(%rip), %rsi     # 0x1403e5
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc94b4(%rip), %rsi     # 0x14040c
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc94da(%rip), %rsi     # 0x14044b
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9509(%rip), %rsi     # 0x140493
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9534(%rip), %rsi     # 0x1404d7
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9566(%rip), %rsi     # 0x140522
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc95d4(%rip), %rsi     # 0x1405a9
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9605(%rip), %rsi     # 0x1405f3
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9630(%rip), %rsi     # 0x140637
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc96ce(%rip), %rsi     # 0x1406ee
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9766(%rip), %rsi     # 0x14079f
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc97cf(%rip), %rsi     # 0x140821
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc97fa(%rip), %rsi     # 0x140865
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc9831(%rip), %rsi     # 0x1408b5
callq 0x43180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc984d(%rip), %rsi     # 0x1408ea
callq 0x43180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x43310
jmp 0x7834d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc9856(%rip), %rsi     # 0x140925
callq 0x26300
cmpl $0x0, %eax
jne 0x770e8
movq $-0x1, %rax
movb $0x78, (%rax)
jmp 0x7834b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc982f(%rip), %rsi     # 0x14092e
callq 0x26300
cmpl $0x0, %eax
je 0x7712e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc9816(%rip), %rsi     # 0x140936
callq 0x26300
cmpl $0x0, %eax
jne 0x771ce
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jl 0x77178
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49ea0
cmpl $0x0, %eax
je 0x77167
jmp 0x7834d
cmpq $0x0, -0x20(%rbp)
jge 0x77176
movq $0x0, -0x20(%rbp)
jmp 0x77178
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc979f(%rip), %rsi     # 0x14092e
callq 0x26300
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x32990
movq -0x8(%rbp), %rdi
leaq 0xc9784(%rip), %rsi     # 0x140948
callq 0x42f90
jmp 0x78349
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc166e(%rip), %rsi     # 0x138853
callq 0x26300
cmpl $0x0, %eax
jne 0x77221
movq $-0x1, %rdi
callq 0x3acd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
leaq 0x101a2d(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78347
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc9741(%rip), %rsi     # 0x140979
callq 0x26300
cmpl $0x0, %eax
jne 0x7729e
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jl 0x7726c
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x491b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rsi
leaq 0xc96fe(%rip), %rdx     # 0x140980
leaq 0xc901b(%rip), %rcx     # 0x1402a4
movl $0x14f, %r8d            # imm = 0x14F
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc96d2(%rip), %rsi     # 0x140987
callq 0x26300
cmpl $0x0, %eax
jne 0x77356
leaq 0x100f0e(%rip), %rax    # 0x1781d8
movq 0x748(%rax), %rdi
callq 0x55050
cmpl $0x0, %eax
je 0x772f4
movq -0x8(%rbp), %rdi
leaq 0x10195a(%rip), %rax    # 0x178c40
movq 0x10(%rax), %rsi
callq 0x42cc0
jmp 0x7834d
xorl %eax, %eax
movl %eax, %edi
callq 0x4adc0
leaq 0x100ed4(%rip), %rax    # 0x1781d8
movq 0x748(%rax), %rdi
callq 0x56470
cmpl $0x0, %eax
je 0x7732a
movq -0x8(%rbp), %rdi
leaq 0xc966e(%rip), %rsi     # 0x14098e
callq 0x42f90
jmp 0x7834d
movl $0x3, %edi
leaq 0xc967a(%rip), %rsi     # 0x1409b0
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rdi
leaq 0x1018f8(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78343
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc965f(%rip), %rsi     # 0x1409cc
callq 0x26300
cmpl $0x0, %eax
jne 0x7740d
leaq 0x100e56(%rip), %rax    # 0x1781d8
cmpl $0x1, 0x668(%rax)
jne 0x77395
movl $0x1, %edi
callq 0x70c00
xorl %eax, %eax
movl %eax, %edi
callq 0x4adc0
leaq 0x100e33(%rip), %rax    # 0x1781d8
movq 0x670(%rax), %rdi
callq 0x72240
cmpl $0x0, %eax
je 0x773cf
movq -0x8(%rbp), %rdi
leaq 0x10187f(%rip), %rax    # 0x178c40
movq 0x10(%rax), %rsi
callq 0x42cc0
jmp 0x7834d
leaq 0x100e02(%rip), %rax    # 0x1781d8
movq $0x0, 0x720(%rax)
movl $0x3, %edi
leaq 0xc95e7(%rip), %rsi     # 0x1409d4
movb $0x0, %al
callq 0x2fc60
movq -0x8(%rbp), %rdi
leaq 0x101841(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78341
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd39dd(%rip), %rsi     # 0x14ae01
callq 0x26300
cmpl $0x0, %eax
jne 0x77816
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77816
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x2dcb0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x77483
movq -0x8(%rbp), %rdi
leaq 0x1017cb(%rip), %rax    # 0x178c40
movq 0x78(%rax), %rsi
callq 0x42cc0
jmp 0x7834d
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %edi
shrl $0x4, %edi
andl $0xf, %edi
callq 0x49fd0
movq %rax, -0x48(%rbp)
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x26110
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x77762
leaq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x80, -0xdc(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rdi
movslq -0xdc(%rbp), %rsi
movq -0xe8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0xc94eb(%rip), %rdx     # 0x1409fd
xorl %eax, %eax
callq 0x26120
movl %eax, -0xec(%rbp)
movslq -0xec(%rbp), %rcx
movq -0xd8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0xec(%rbp), %ecx
movl -0xdc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xdc(%rbp)
movq -0xe8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0xbff42(%rip), %xmm1    # 0x1374a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xbff46(%rip), %xmm1    # 0x1374b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl 0x18(%rax), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xf8(%rbp)
movq -0xd8(%rbp), %rdi
movslq -0xdc(%rbp), %rsi
movsd -0xf8(%rbp), %xmm0
leaq 0xc9460(%rip), %rdx     # 0x140a0a
movb $0x1, %al
callq 0x26120
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0xec(%rbp), %ecx
movl -0xdc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xdc(%rbp)
movq -0xd8(%rbp), %rdi
movslq -0xdc(%rbp), %rsi
movq -0xe8(%rbp), %rax
movl 0x1c(%rax), %ecx
shll $0x10, %ecx
sarl $0x10, %ecx
leaq 0xc9412(%rip), %rdx     # 0x140a1c
movb $0x0, %al
callq 0x26120
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0xec(%rbp), %ecx
movl -0xdc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xdc(%rbp)
movq -0xe8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x10, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xfc(%rbp)
movq -0xd8(%rbp), %rdi
movslq -0xdc(%rbp), %rsi
movl -0xfc(%rbp), %ecx
leaq 0xc93b1(%rip), %rdx     # 0x140a2f
movb $0x0, %al
callq 0x26120
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0xec(%rbp), %ecx
movl -0xdc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xdc(%rbp)
movq $0x0, -0x108(%rbp)
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x110(%rbp)
je 0x7770b
movq -0x110(%rbp), %rax
movl 0x18(%rax), %eax
addq -0x108(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x110(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x110(%rbp)
jmp 0x776d5
movq -0xd8(%rbp), %rdi
movslq -0xdc(%rbp), %rsi
movq -0x108(%rbp), %rcx
leaq 0xc931a(%rip), %rdx     # 0x140a41
movb $0x0, %al
callq 0x26120
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movl -0xec(%rbp), %ecx
movl -0xdc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xdc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x12b0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x1288(%rbp)
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x12a4(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x12a0(%rbp)
movq -0x40(%rbp), %rdi
callq 0x547c0
movq %rax, -0x1298(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x128c(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4a080
movq -0x12b0(%rbp), %rdi
movl -0x12a4(%rbp), %ecx
movq -0x12a0(%rbp), %r8
movq -0x1298(%rbp), %r9
movl -0x128c(%rbp), %r11d
movl $0x3e8, %esi            # imm = 0x3E8
xorl %edx, %edx
divq %rsi
movq -0x1288(%rbp), %rdx
movq %rax, %r10
leaq -0xd0(%rbp), %rax
leaq 0xc925f(%rip), %rsi     # 0x140a5b
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x431c0
jmp 0x7833f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc9286(%rip), %rsi     # 0x140ab3
callq 0x26300
cmpl $0x0, %eax
jne 0x7798a
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x7798a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x2dcb0
movq %rax, -0x118(%rbp)
cmpq $0x0, %rax
jne 0x7788f
movq -0x8(%rbp), %rdi
leaq 0x1013bf(%rip), %rax    # 0x178c40
movq 0x78(%rax), %rsi
callq 0x42cc0
jmp 0x7834d
movq -0x118(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x778eb
movq -0x120(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x77900
movq -0x120(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x77900
movq -0x8(%rbp), %rdi
leaq 0xc91c4(%rip), %rsi     # 0x140aba
callq 0x42f90
jmp 0x77985
movq -0x8(%rbp), %rax
movq %rax, -0x12d0(%rbp)
movq -0x128(%rbp), %rdi
callq 0x76360
movq %rax, -0x12c8(%rbp)
movq -0x128(%rbp), %rdi
callq 0x783c0
movq %rax, -0x12c0(%rbp)
movq -0x120(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x76360
movq %rax, -0x12b8(%rbp)
movq -0x120(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x783c0
movq -0x12d0(%rbp), %rdi
movq -0x12c8(%rbp), %rdx
movq -0x12c0(%rbp), %rcx
movq -0x12b8(%rbp), %r8
movq %rax, %r9
leaq 0xc9157(%rip), %rsi     # 0x140ad5
movb $0x0, %al
callq 0x431c0
jmp 0x7833d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc917f(%rip), %rsi     # 0x140b20
callq 0x26300
cmpl $0x0, %eax
jne 0x77ba5
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
je 0x779c7
movq -0x8(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x77ba5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x130(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49f20
cmpl $0x0, %eax
je 0x779f1
jmp 0x7834d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x130(%rbp), %rsi
callq 0x2d440
movq $0x0, -0x138(%rbp)
movq -0x138(%rbp), %rax
cmpq -0x130(%rbp), %rax
jge 0x77b8c
leaq -0x1d0(%rbp), %rax
movq %rax, -0x12d8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77a4f
leaq 0xd1678(%rip), %rax     # 0x1490be
movq %rax, -0x12e0(%rbp)
jmp 0x77a66
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x12e0(%rbp)
movq -0x12d8(%rbp), %rdi
movq -0x12e0(%rbp), %rcx
movq -0x138(%rbp), %r8
movl $0x80, %esi
leaq 0xc90a2(%rip), %rdx     # 0x140b29
movb $0x0, %al
callq 0x26120
leaq -0x1d0(%rbp), %rax
movq %rax, -0x12e8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x264f0
movq -0x12e8(%rbp), %rdi
movq %rax, %rsi
callq 0x486a0
movq %rax, -0x140(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x140(%rbp), %rsi
callq 0x4a6f0
cmpq $0x0, %rax
je 0x77ae9
movq -0x140(%rbp), %rdi
callq 0x48f70
jmp 0x77b75
leaq -0x1d0(%rbp), %rdi
movq -0x138(%rbp), %rcx
movl $0x80, %esi
leaq 0xc902d(%rip), %rdx     # 0x140b30
movb $0x0, %al
callq 0x26120
leaq -0x1d0(%rbp), %rax
movq %rax, -0x12f0(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x264f0
movq -0x12f0(%rbp), %rdi
movq %rax, %rsi
callq 0x486a0
movq %rax, -0x148(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x140(%rbp), %rsi
movq -0x148(%rbp), %rdx
callq 0x4a7d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x140(%rbp), %rsi
callq 0x4aa60
movq -0x140(%rbp), %rdi
callq 0x48f70
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
jmp 0x77a13
movq -0x8(%rbp), %rdi
leaq 0x1010a9(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x7833b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8f7e(%rip), %rsi     # 0x140b3a
callq 0x26300
cmpl $0x0, %eax
jne 0x77c60
movq -0x8(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jne 0x77c60
callq 0x384f0
movq %rax, -0x1f8(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x764c0
movl $0x0, -0x1fc(%rbp)
cmpl $0x14, -0x1fc(%rbp)
jge 0x77c3f
movq -0x1f8(%rbp), %rdi
movslq -0x1fc(%rbp), %rax
movzbl -0x1f0(%rbp,%rax), %edx
leaq 0xc2bb6(%rip), %rsi     # 0x13a7d6
movb $0x0, %al
callq 0x395b0
movq %rax, -0x1f8(%rbp)
movl -0x1fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1fc(%rbp)
jmp 0x77bfa
movq -0x8(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0x43180
movq -0x1f8(%rbp), %rdi
callq 0x38620
jmp 0x78339
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8eca(%rip), %rsi     # 0x140b41
callq 0x26300
cmpl $0x0, %eax
jne 0x77d30
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77d30
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x26cd0
movsd %xmm0, -0x208(%rbp)
movsd 0xc542c(%rip), %xmm0    # 0x13d0e8
mulsd -0x208(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x210(%rbp)
movq -0x210(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x220(%rbp)
movq -0x210(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, -0x218(%rbp)
leaq -0x220(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x26960
movq -0x8(%rbp), %rdi
leaq 0x100f1e(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78337
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8e00(%rip), %rsi     # 0x140b47
callq 0x26300
cmpl $0x0, %eax
jne 0x77d98
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77d98
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x26760
movl %eax, %ecx
leaq 0x10045f(%rip), %rax    # 0x1781d8
movl %ecx, 0x604(%rax)
movq -0x8(%rbp), %rdi
leaq 0x100eb6(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78335
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8daa(%rip), %rsi     # 0x140b59
callq 0x26300
cmpl $0x0, %eax
jne 0x77e00
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77e00
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x26760
movl %eax, %ecx
leaq 0x1003f7(%rip), %rax    # 0x1781d8
movl %ecx, 0xa14(%rax)
movq -0x8(%rbp), %rdi
leaq 0x100e4e(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x78333
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc5777(%rip), %rsi     # 0x13d58e
callq 0x26300
cmpl $0x0, %eax
jne 0x77ec8
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x77ec8
leaq 0xd3650(%rip), %rdi     # 0x14b48a
movl $0x1, %esi
callq 0x38230
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x39110
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
leaq 0xc8cfb(%rip), %rsi     # 0x140b77
leaq 0xcc7f8(%rip), %rdx     # 0x14467b
movl $0x2, %ecx
callq 0x3aa80
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
leaq 0xc63e6(%rip), %rsi     # 0x13e288
movl $0x2, %edx
callq 0x39040
movq %rax, -0x228(%rbp)
movq -0x8(%rbp), %rdi
movq -0x228(%rbp), %rsi
callq 0x42e50
jmp 0x78331
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8c9b(%rip), %rsi     # 0x140b7a
callq 0x26300
cmpl $0x0, %eax
jne 0x78024
movq -0x8(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jne 0x78024
callq 0x384f0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c70(%rip), %rsi     # 0x140b85
movl $0x40, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c58(%rip), %rsi     # 0x140b8e
movl $0x10, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c40(%rip), %rsi     # 0x140b97
movl $0x18, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c2d(%rip), %rsi     # 0x140ba5
movl $0x1, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c18(%rip), %rsi     # 0x140bb1
movl $0x3, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8c03(%rip), %rsi     # 0x140bbd
movl $0x5, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8bef(%rip), %rsi     # 0x140bca
movl $0x9, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rdi
leaq 0xc8bdb(%rip), %rsi     # 0x140bd7
movl $0x11, %edx
movb $0x0, %al
callq 0x395b0
movq %rax, -0x230(%rbp)
movq -0x8(%rbp), %rdi
movq -0x230(%rbp), %rsi
callq 0x43970
jmp 0x7832f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8ba9(%rip), %rsi     # 0x140be4
callq 0x26300
cmpl $0x0, %eax
jne 0x781a2
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x781a2
callq 0x384f0
movq %rax, -0x240(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x238(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49f20
cmpl $0x0, %eax
je 0x7808d
jmp 0x7834d
cmpq $0x0, -0x238(%rbp)
jl 0x780b1
movq -0x238(%rbp), %rax
leaq 0x100133(%rip), %rcx    # 0x1781d8
movslq 0x610(%rcx), %rcx
cmpq %rcx, %rax
jl 0x780c6
movq -0x8(%rbp), %rdi
leaq 0xc8b30(%rip), %rsi     # 0x140bec
callq 0x42f90
jmp 0x7834d
movq -0x240(%rbp), %rdi
leaq 0xc8b2e(%rip), %rsi     # 0x140c02
movb $0x0, %al
callq 0x395b0
movq %rax, -0x240(%rbp)
leaq -0x1240(%rbp), %rdi
leaq 0x1000e8(%rip), %rax    # 0x1781d8
movq 0x28(%rax), %rax
movq -0x238(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x2f340
movq -0x240(%rbp), %rdi
leaq -0x1240(%rbp), %rsi
callq 0x390d0
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rdi
leaq 0xc8adc(%rip), %rsi     # 0x140c13
movb $0x0, %al
callq 0x395b0
movq %rax, -0x240(%rbp)
leaq -0x1240(%rbp), %rdi
leaq 0x100085(%rip), %rax    # 0x1781d8
movq 0x28(%rax), %rax
movq -0x238(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x2f340
movq -0x240(%rbp), %rdi
leaq -0x1240(%rbp), %rsi
callq 0x390d0
movq %rax, -0x240(%rbp)
movq -0x8(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0x43970
jmp 0x7832d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8a68(%rip), %rsi     # 0x140c21
callq 0x26300
cmpl $0x0, %eax
jne 0x78309
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x78309
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd2a68(%rip), %rsi     # 0x14ac54
callq 0x26300
cmpl $0x0, %eax
jne 0x7822e
callq 0x384f0
movq %rax, -0x1248(%rbp)
leaq -0x13e9(%rip), %rdi     # 0x76e20
leaq -0x1248(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xea4a0
movq -0x8(%rbp), %rdi
movq -0x1248(%rbp), %rsi
callq 0x43970
jmp 0x78307
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xc8a40(%rip), %rsi     # 0x140c85
callq 0x26300
cmpl $0x0, %eax
jne 0x782f3
movl $0x0, -0x1274(%rbp)
movq $0x4, -0x1280(%rbp)
leaq 0xc89bb(%rip), %rdi     # 0x140c2a
leaq -0x1274(%rbp), %rsi
leaq -0x1280(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xe9ea0
cmpl $0x0, %eax
jne 0x782e1
leaq -0x1270(%rbp), %rdi
movl -0x1274(%rbp), %edx
leaq 0xc8996(%rip), %rsi     # 0x140c39
movb $0x0, %al
callq 0x26570
leaq -0x1270(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
callq 0xe9ea0
cmpl $0x0, %eax
jne 0x782df
movq -0x8(%rbp), %rdi
leaq 0x10096c(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x7834d
jmp 0x782e1
movq -0x8(%rbp), %rdi
leaq 0xc895c(%rip), %rsi     # 0x140c48
callq 0x42f90
jmp 0x78305
movq -0x8(%rbp), %rdi
leaq 0xc8964(%rip), %rsi     # 0x140c62
movb $0x0, %al
callq 0x42fd0
jmp 0x78307
jmp 0x7832b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xc8967(%rip), %rsi     # 0x140c8b
movb $0x0, %al
callq 0x42fd0
jmp 0x7832d
jmp 0x7832f
jmp 0x78331
jmp 0x78333
jmp 0x78335
jmp 0x78337
jmp 0x78339
jmp 0x7833b
jmp 0x7833d
jmp 0x7833f
jmp 0x78341
jmp 0x78343
jmp 0x78345
jmp 0x78347
jmp 0x78349
jmp 0x7834b
jmp 0x7834d
addq $0x1310, %rsp           # imm = 0x1310
popq %rbp
retq
nopw %cs:(%rax,%rax)