// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/rdb.c
// Function: rdbLoadObject
robj *rdbLoadObject(int rdbtype, rio *rdb) {
    robj *o = NULL, *ele, *dec;
    size_t len;
    unsigned int i;

    if (rdbtype == RDB_TYPE_STRING) {
        /* Read string value */
        if ((o = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL;
        o = tryObjectEncoding(o);
    } else if (rdbtype == RDB_TYPE_LIST) {
        /* Read list value */
        if ((len = rdbLoadLen(rdb,NULL)) == RDB_LENERR) return NULL;

        o = createQuicklistObject();
        quicklistSetOptions(o->ptr, server.list_max_ziplist_size,
                            server.list_compress_depth);

        /* Load every single element of the list */
        while(len--) {
            if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL;
            dec = getDecodedObject(ele);
            size_t len = sdslen(dec->ptr);
            quicklistPushTail(o->ptr, dec->ptr, len);
            decrRefCount(dec);
            decrRefCount(ele);
        }
    } else if (rdbtype == RDB_TYPE_SET) {
        /* Read list/set value */
        if ((len = rdbLoadLen(rdb,NULL)) == RDB_LENERR) return NULL;

        /* Use a regular set when there are too many entries. */
        if (len > server.set_max_intset_entries) {
            o = createSetObject();
            /* It's faster to expand the dict to the right size asap in order
             * to avoid rehashing */
            if (len > DICT_HT_INITIAL_SIZE)
                dictExpand(o->ptr,len);
        } else {
            o = createIntsetObject();
        }

        /* Load every single element of the list/set */
        for (i = 0; i < len; i++) {
            long long llval;
            if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL;
            ele = tryObjectEncoding(ele);

            if (o->encoding == OBJ_ENCODING_INTSET) {
                /* Fetch integer value from element */
                if (isObjectRepresentableAsLongLong(ele,&llval) == C_OK) {
                    o->ptr = intsetAdd(o->ptr,llval,NULL);
                } else {
                    setTypeConvert(o,OBJ_ENCODING_HT);
                    dictExpand(o->ptr,len);
                }
            }

            /* This will also be called when the set was just converted
             * to a regular hash table encoded set */
            if (o->encoding == OBJ_ENCODING_HT) {
                dictAdd((dict*)o->ptr,ele,NULL);
            } else {
                decrRefCount(ele);
            }
        }
    } else if (rdbtype == RDB_TYPE_ZSET) {
        /* Read list/set value */
        size_t zsetlen;
        size_t maxelelen = 0;
        zset *zs;

        if ((zsetlen = rdbLoadLen(rdb,NULL)) == RDB_LENERR) return NULL;
        o = createZsetObject();
        zs = o->ptr;

        /* Load every single element of the list/set */
        while(zsetlen--) {
            robj *ele;
            double score;
            zskiplistNode *znode;

            if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL;
            ele = tryObjectEncoding(ele);
            if (rdbLoadDoubleValue(rdb,&score) == -1) return NULL;

            /* Don't care about integer-encoded strings. */
            if (sdsEncodedObject(ele) && sdslen(ele->ptr) > maxelelen)
                maxelelen = sdslen(ele->ptr);

            znode = zslInsert(zs->zsl,score,ele);
            dictAdd(zs->dict,ele,&znode->score);
            incrRefCount(ele); /* added to skiplist */
        }

        /* Convert *after* loading, since sorted sets are not stored ordered. */
        if (zsetLength(o) <= server.zset_max_ziplist_entries &&
            maxelelen <= server.zset_max_ziplist_value)
                zsetConvert(o,OBJ_ENCODING_ZIPLIST);
    } else if (rdbtype == RDB_TYPE_HASH) {
        size_t len;
        int ret;

        len = rdbLoadLen(rdb, NULL);
        if (len == RDB_LENERR) return NULL;

        o = createHashObject();

        /* Too many entries? Use a hash table. */
        if (len > server.hash_max_ziplist_entries)
            hashTypeConvert(o, OBJ_ENCODING_HT);

        /* Load every field and value into the ziplist */
        while (o->encoding == OBJ_ENCODING_ZIPLIST && len > 0) {
            robj *field, *value;

            len--;
            /* Load raw strings */
            field = rdbLoadStringObject(rdb);
            if (field == NULL) return NULL;
            serverAssert(sdsEncodedObject(field));
            value = rdbLoadStringObject(rdb);
            if (value == NULL) return NULL;
            serverAssert(sdsEncodedObject(value));

            /* Add pair to ziplist */
            o->ptr = ziplistPush(o->ptr, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
            o->ptr = ziplistPush(o->ptr, value->ptr, sdslen(value->ptr), ZIPLIST_TAIL);
            /* Convert to hash table if size threshold is exceeded */
            if (sdslen(field->ptr) > server.hash_max_ziplist_value ||
                sdslen(value->ptr) > server.hash_max_ziplist_value)
            {
                decrRefCount(field);
                decrRefCount(value);
                hashTypeConvert(o, OBJ_ENCODING_HT);
                break;
            }
            decrRefCount(field);
            decrRefCount(value);
        }

        /* Load remaining fields and values into the hash table */
        while (o->encoding == OBJ_ENCODING_HT && len > 0) {
            robj *field, *value;

            len--;
            /* Load encoded strings */
            field = rdbLoadEncodedStringObject(rdb);
            if (field == NULL) return NULL;
            value = rdbLoadEncodedStringObject(rdb);
            if (value == NULL) return NULL;

            field = tryObjectEncoding(field);
            value = tryObjectEncoding(value);

            /* Add pair to hash table */
            ret = dictAdd((dict*)o->ptr, field, value);
            if (ret == DICT_ERR) {
                rdbExitReportCorruptRDB("Duplicate keys detected");
            }
        }

        /* All pairs should be read by now */
        serverAssert(len == 0);
    } else if (rdbtype == RDB_TYPE_LIST_QUICKLIST) {
        if ((len = rdbLoadLen(rdb,NULL)) == RDB_LENERR) return NULL;
        o = createQuicklistObject();
        quicklistSetOptions(o->ptr, server.list_max_ziplist_size,
                            server.list_compress_depth);

        while (len--) {
            unsigned char *zl = rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN);
            if (zl == NULL) return NULL;
            quicklistAppendZiplist(o->ptr, zl);
        }
    } else if (rdbtype == RDB_TYPE_HASH_ZIPMAP  ||
               rdbtype == RDB_TYPE_LIST_ZIPLIST ||
               rdbtype == RDB_TYPE_SET_INTSET   ||
               rdbtype == RDB_TYPE_ZSET_ZIPLIST ||
               rdbtype == RDB_TYPE_HASH_ZIPLIST)
    {
        unsigned char *encoded = rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN);
        if (encoded == NULL) return NULL;
        o = createObject(OBJ_STRING,encoded); /* Obj type fixed below. */

        /* Fix the object encoding, and make sure to convert the encoded
         * data type into the base type if accordingly to the current
         * configuration there are too many elements in the encoded data
         * type. Note that we only check the length and not max element
         * size as this is an O(N) scan. Eventually everything will get
         * converted. */
        switch(rdbtype) {
            case RDB_TYPE_HASH_ZIPMAP:
                /* Convert to ziplist encoded hash. This must be deprecated
                 * when loading dumps created by Redis 2.4 gets deprecated. */
                {
                    unsigned char *zl = ziplistNew();
                    unsigned char *zi = zipmapRewind(o->ptr);
                    unsigned char *fstr, *vstr;
                    unsigned int flen, vlen;
                    unsigned int maxlen = 0;

                    while ((zi = zipmapNext(zi, &fstr, &flen, &vstr, &vlen)) != NULL) {
                        if (flen > maxlen) maxlen = flen;
                        if (vlen > maxlen) maxlen = vlen;
                        zl = ziplistPush(zl, fstr, flen, ZIPLIST_TAIL);
                        zl = ziplistPush(zl, vstr, vlen, ZIPLIST_TAIL);
                    }

                    zfree(o->ptr);
                    o->ptr = zl;
                    o->type = OBJ_HASH;
                    o->encoding = OBJ_ENCODING_ZIPLIST;

                    if (hashTypeLength(o) > server.hash_max_ziplist_entries ||
                        maxlen > server.hash_max_ziplist_value)
                    {
                        hashTypeConvert(o, OBJ_ENCODING_HT);
                    }
                }
                break;
            case RDB_TYPE_LIST_ZIPLIST:
                o->type = OBJ_LIST;
                o->encoding = OBJ_ENCODING_ZIPLIST;
                listTypeConvert(o,OBJ_ENCODING_QUICKLIST);
                break;
            case RDB_TYPE_SET_INTSET:
                o->type = OBJ_SET;
                o->encoding = OBJ_ENCODING_INTSET;
                if (intsetLen(o->ptr) > server.set_max_intset_entries)
                    setTypeConvert(o,OBJ_ENCODING_HT);
                break;
            case RDB_TYPE_ZSET_ZIPLIST:
                o->type = OBJ_ZSET;
                o->encoding = OBJ_ENCODING_ZIPLIST;
                if (zsetLength(o) > server.zset_max_ziplist_entries)
                    zsetConvert(o,OBJ_ENCODING_SKIPLIST);
                break;
            case RDB_TYPE_HASH_ZIPLIST:
                o->type = OBJ_HASH;
                o->encoding = OBJ_ENCODING_ZIPLIST;
                if (hashTypeLength(o) > server.hash_max_ziplist_entries)
                    hashTypeConvert(o, OBJ_ENCODING_HT);
                break;
            default:
                rdbExitReportCorruptRDB("Unknown RDB encoding type %d",rdbtype);
                break;
        }
    } else {
        rdbExitReportCorruptRDB("Unknown RDB encoding type %d",rdbtype);
    }
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %r15d
cmpl $0xe, %edi
ja 0x4d0d3
movl %r15d, %eax
leaq 0x787bb(%rip), %rcx     # 0xc5798
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d825
movq %rax, %rdi
callq 0x4426d
movq %rax, %rbx
jmp 0x4d827
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4b10c
cmpl $-0x1, %eax
je 0x4d827
movl %eax, %ebp
movl %eax, %r15d
leaq 0xb982b(%rip), %rax     # 0x106858
cmpq %r15, 0x940(%rax)
jae 0x4d749
callq 0x43e92
movq %rax, %rbx
cmpl $0x5, %ebp
jb 0x4d751
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x317e2
jmp 0x4d751
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4b10c
cmpl $-0x1, %eax
je 0x4d827
movl %eax, %ebp
callq 0x43e25
movq %rax, %rbx
movq 0x8(%rax), %rdi
leaq 0xb97d2(%rip), %rax     # 0x106858
movl 0x960(%rax), %esi
movl 0x964(%rax), %edx
callq 0x2e774
testl %ebp, %ebp
je 0x4d827
movq %rbx, %r15
movl %ebp, %ebx
movq %r14, %rdi
movl $0x2, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d825
movq 0x8(%r15), %rdi
movq %rax, %rsi
callq 0x2ebf1
decq %rbx
jne 0x4d0a4
movq %r15, %rbx
jmp 0x4d827
leal -0x9(%r15), %ebx
cmpl $0x4, %ebx
ja 0x4d925
movq %r14, %rdi
movl $0x2, %esi
callq 0x4bb16
movq %rax, %r12
testq %rax, %rax
je 0x4d70b
xorl %edi, %edi
movq %r12, %rsi
callq 0x43ab4
cmpl $0x4, %ebx
ja 0x4d93b
movq %rax, %r14
leaq 0x7874a(%rip), %rax     # 0xc5860
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
callq 0x3e2e3
movq %rax, %r15
movq %r14, %rbx
movq 0x8(%r14), %rdi
callq 0x3c97a
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rax, %rdi
callq 0x3c97f
xorl %ebp, %ebp
testq %rax, %rax
je 0x4d1ca
movq %rax, %r13
movq %r12, (%rsp)
leaq 0x20(%rsp), %r14
leaq 0xc(%rsp), %r12
movl 0x1c(%rsp), %edx
cmpl %ebp, %edx
cmoval %edx, %ebp
movl 0xc(%rsp), %eax
cmpl %ebp, %eax
cmoval %eax, %ebp
movq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %ecx
callq 0x3ea1e
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x3ea1e
movq %rax, %r15
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x3c97f
movq %rax, %r13
testq %rax, %rax
jne 0x4d167
movl %ebp, %ebp
movq (%rsp), %r12
movq 0x8(%rbx), %rdi
callq 0x3b3df
movq %r15, 0x8(%rbx)
movb $0x54, (%rbx)
movq %rbx, %rdi
callq 0x5948d
leaq 0xb966f(%rip), %rcx     # 0x106858
cmpq 0x930(%rcx), %rax
ja 0x4d85c
cmpq %rbp, 0x938(%rcx)
jae 0x4d8e0
jmp 0x4d85c
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4b10c
cmpl $-0x1, %eax
je 0x4d827
movl %eax, %ebp
callq 0x43e25
movq %rax, %rbx
movq 0x8(%rax), %rdi
leaq 0xb9626(%rip), %rax     # 0x106858
movl 0x960(%rax), %esi
movl 0x964(%rax), %edx
callq 0x2e774
testl %ebp, %ebp
je 0x4d827
movl %ebp, %r13d
leaq 0x785f7(%rip), %rbp     # 0xc584c
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d825
movq %rax, %r15
movq %rax, %rdi
callq 0x444b2
movq %rax, %r12
movq 0x8(%rax), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x4d2b1
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x4d2b3
movq -0x11(%rsi), %rdx
jmp 0x4d2b3
movzwl -0x5(%rsi), %edx
jmp 0x4d2b3
movl -0x9(%rsi), %edx
jmp 0x4d2b3
movzbl -0x3(%rsi), %edx
jmp 0x4d2b3
xorl %edx, %edx
decq %r13
movq 0x8(%rbx), %rdi
callq 0x26e43
movq %r12, %rdi
callq 0x440f3
movq %r15, %rdi
callq 0x440f3
testq %r13, %r13
jne 0x4d255
jmp 0x4d827
movq %r14, %rdi
xorl %esi, %esi
callq 0x4b10c
cmpl $-0x1, %eax
je 0x4d6f6
movl %eax, %r13d
callq 0x43f3a
movq %rax, %rbx
movq 0x8(%rax), %rbp
incq %r13
xorl %r15d, %r15d
decq %r13
je 0x4d712
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d372
movq %rax, %rdi
callq 0x4426d
movq %rax, %r12
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4bd6c
cmpl $-0x1, %eax
je 0x4d372
movl (%r12), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x4d3d3
movq 0x8(%r12), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x4d390
leaq 0x784c2(%rip), %rdi     # 0xc5824
movslq (%rdi,%rdx,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
movl %ecx, %esi
shrl $0x3, %esi
jmp 0x4d392
xorl %eax, %eax
jmp 0x4d3ff
movq -0x11(%rax), %rsi
jmp 0x4d392
movzwl -0x5(%rax), %esi
jmp 0x4d392
movl -0x9(%rax), %esi
jmp 0x4d392
movzbl -0x3(%rax), %esi
jmp 0x4d392
xorl %esi, %esi
cmpq %r15, %rsi
jbe 0x4d3d3
cmpl $0x4, %edx
ja 0x4d3d0
movl %edx, %edx
leaq 0x78493(%rip), %rsi     # 0xc5838
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
movq %rcx, %r15
jmp 0x4d3d3
movq -0x11(%rax), %r15
jmp 0x4d3d3
movzwl -0x5(%rax), %r15d
jmp 0x4d3d3
movl -0x9(%rax), %r15d
jmp 0x4d3d3
movzbl -0x3(%rax), %r15d
jmp 0x4d3d3
xorl %r15d, %r15d
movq 0x8(%rbp), %rdi
movsd 0x10(%rsp), %xmm0
movq %r12, %rsi
callq 0x5361a
movq (%rbp), %rdi
leaq 0x8(%rax), %rdx
movq %r12, %rsi
callq 0x31a95
movq %r12, %rdi
callq 0x43c0c
movb $0x1, %al
testb %al, %al
jne 0x4d301
movq %rbx, %r14
jmp 0x4d6f9
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4b10c
cmpl $-0x1, %eax
je 0x4d6ef
movl %eax, %ebx
callq 0x43f05
movq %rax, (%rsp)
leaq 0xb9422(%rip), %rax     # 0x106858
cmpq %rbx, 0x930(%rax)
jae 0x4d44d
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x58e11
movq (%rsp), %rax
movl (%rax), %eax
movl $0xf0, %ecx
andl %ecx, %eax
cmpl $0x50, %eax
jne 0x4d655
testq %rbx, %rbx
je 0x4d655
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x4bb16
movl $0x1, %r13d
testq %rax, %rax
je 0x4d63f
movq %rax, %r15
movl (%rax), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x4d8ee
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d63f
movq %rax, %r12
movl (%rax), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x4d903
movq 0x8(%r15), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x4d4fa
leaq 0x782ff(%rip), %rcx     # 0xc57d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x4d4fc
movq -0x11(%rsi), %rdx
jmp 0x4d4fc
movzwl -0x5(%rsi), %edx
jmp 0x4d4fc
movl -0x9(%rsi), %edx
jmp 0x4d4fc
movzbl -0x3(%rsi), %edx
jmp 0x4d4fc
xorl %edx, %edx
movq (%rsp), %r13
movq 0x8(%r13), %rdi
movl $0x1, %ecx
callq 0x3ea1e
movq %rax, 0x8(%r13)
movq 0x8(%r12), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x4d551
leaq 0x782bc(%rip), %rdi     # 0xc57e8
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
shrl $0x3, %edx
jmp 0x4d553
movq -0x11(%rsi), %rdx
jmp 0x4d553
movzwl -0x5(%rsi), %edx
jmp 0x4d553
movl -0x9(%rsi), %edx
jmp 0x4d553
movzbl -0x3(%rsi), %edx
jmp 0x4d553
xorl %edx, %edx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x3ea1e
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x4d5a6
leaq 0x7827b(%rip), %rsi     # 0xc57fc
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x4d5a8
movq -0x11(%rax), %rcx
jmp 0x4d5a8
movzwl -0x5(%rax), %ecx
jmp 0x4d5a8
movl -0x9(%rax), %ecx
jmp 0x4d5a8
movzbl -0x3(%rax), %ecx
jmp 0x4d5a8
xorl %ecx, %ecx
leaq 0xb92a9(%rip), %rax     # 0x106858
movq 0x938(%rax), %rax
cmpq %rax, %rcx
ja 0x4d601
movq 0x8(%r12), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %esi
andl $0x7, %esi
cmpl $0x4, %esi
ja 0x4d5fa
leaq 0x7823b(%rip), %rdi     # 0xc5810
movslq (%rdi,%rsi,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
shrl $0x3, %ecx
jmp 0x4d5fc
movq -0x11(%rdx), %rcx
jmp 0x4d5fc
movzwl -0x5(%rdx), %ecx
jmp 0x4d5fc
movl -0x9(%rdx), %ecx
jmp 0x4d5fc
movzbl -0x3(%rdx), %ecx
jmp 0x4d5fc
xorl %ecx, %ecx
cmpq %rax, %rcx
jbe 0x4d629
movq %r15, %rdi
callq 0x440f3
movq %r12, %rdi
callq 0x440f3
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x58e11
movl $0xa, %r13d
xorl %ebp, %ebp
jmp 0x4d63f
movq %r15, %rdi
callq 0x440f3
movq %r12, %rdi
callq 0x440f3
xorl %r13d, %r13d
movb $0x1, %bpl
decq %rbx
testl %r13d, %r13d
je 0x4d44d
cmpl $0xa, %r13d
jne 0x4d81c
movl $0xf0, %ebp
movq %rbx, %r13
movq (%rsp), %rcx
movl (%rcx), %ecx
andl %ebp, %ecx
addq $-0x1, %r13
setb %al
cmpl $0x20, %ecx
jne 0x4d7f6
testb %al, %al
je 0x4d7f6
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d81a
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
movq (%rsp), %rbx
je 0x4d6ef
movq %rax, %r12
movq %r15, %rdi
callq 0x4426d
movq %rax, %r15
movq %r12, %rdi
callq 0x4426d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x31a95
movq %rbx, %rcx
movq %r13, %rbx
cmpl $0x1, %eax
jne 0x4d661
leaq 0x78507(%rip), %rsi     # 0xc5bea
movl $0x46c, %edi            # imm = 0x46C
xorl %eax, %eax
callq 0x4ac2c
xorl %ebp, %ebp
jmp 0x4d820
xorl %r14d, %r14d
xorl %ebx, %ebx
testb %bl, %bl
movq %r14, %rbx
je 0x4d825
jmp 0x4d827
xorl %ebx, %ebx
jmp 0x4d8e0
movq %rbx, %r14
movq %rbx, %rdi
callq 0x551a5
movl %eax, %ecx
leaq 0xb9132(%rip), %rax     # 0x106858
movb $0x1, %bl
cmpq %rcx, 0x948(%rax)
jb 0x4d6fb
cmpq 0x950(%rax), %r15
ja 0x4d6fb
movq %r14, %rdi
movl $0x5, %esi
callq 0x551f4
jmp 0x4d6fb
callq 0x43ed0
movq %rax, %rbx
testl %ebp, %ebp
je 0x4d827
movl $0xf0, %r12d
movq %r14, %rdi
movl $0x1, %esi
callq 0x4bb16
testq %rax, %rax
je 0x4d825
movq %rax, %rdi
callq 0x4426d
movq %rax, %r13
movl (%rbx), %eax
andl %r12d, %eax
cmpl $0x60, %eax
jne 0x4d7ca
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x441d1
testl %eax, %eax
je 0x4d7b6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x518a9
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x317e2
jmp 0x4d7ca
movq 0x8(%rbx), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x68634
movq %rax, 0x8(%rbx)
movl (%rbx), %eax
andl %r12d, %eax
cmpl $0x20, %eax
jne 0x4d7e4
movq 0x8(%rbx), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x31a95
jmp 0x4d7ec
movq %r13, %rdi
callq 0x440f3
decl %ebp
jne 0x4d75f
jmp 0x4d827
movb $0x1, %bpl
testq %rbx, %rbx
movq (%rsp), %rbx
je 0x4d820
leaq 0x783f9(%rip), %rdi     # 0xc5c02
leaq 0x7817e(%rip), %rsi     # 0xc598e
movl $0x471, %edx            # imm = 0x471
jmp 0x4d916
xorl %ebp, %ebp
movq (%rsp), %rbx
testb %bpl, %bpl
jne 0x4d827
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rbx
movb $0x54, (%r14)
movq %r14, %rdi
callq 0x5948d
leaq 0xb9009(%rip), %rcx     # 0x106858
cmpq 0x930(%rcx), %rax
jbe 0x4d8e0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x58e11
jmp 0x4d8e0
movq %r14, %rbx
movb $0x62, (%r14)
movq 0x8(%r14), %rdi
callq 0x68a6e
movl %eax, %eax
leaq 0xb8fd4(%rip), %rcx     # 0x106858
cmpq %rax, 0x940(%rcx)
jae 0x4d8e0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x518a9
jmp 0x4d8e0
movq %r14, %rbx
movb $0x53, (%r14)
movq %r14, %rdi
callq 0x551a5
movl %eax, %eax
leaq 0xb8fa4(%rip), %rcx     # 0x106858
cmpq %rax, 0x948(%rcx)
jae 0x4d8e0
movq %rbx, %rdi
movl $0x7, %esi
callq 0x551f4
jmp 0x4d8e0
movq %r14, %rbx
movb $0x51, (%r14)
movq %r14, %rdi
movl $0x9, %esi
callq 0x4ff2f
testq %r12, %r12
jne 0x4d827
jmp 0x4d825
leaq 0x782c5(%rip), %rdi     # 0xc5bba
leaq 0x78092(%rip), %rsi     # 0xc598e
movl $0x446, %edx            # imm = 0x446
jmp 0x4d916
leaq 0x782c8(%rip), %rdi     # 0xc5bd2
leaq 0x7807d(%rip), %rsi     # 0xc598e
movl $0x449, %edx            # imm = 0x449
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
leaq 0x782df(%rip), %rsi     # 0xc5c0b
movl $0x4c7, %edi            # imm = 0x4C7
movl %r15d, %edx
xorl %eax, %eax
callq 0x4ac2c
leaq 0x782c9(%rip), %rsi     # 0xc5c0b
movl $0x4c3, %edi            # imm = 0x4C3
jmp 0x4d931