// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/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, %edx
cmpl $0xe, %edi
ja 0x49ace
movl %edx, %eax
leaq 0x78e51(%rip), %rcx     # 0xc2828
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40e09
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x47db6
cmpl $-0x1, %eax
je 0x4a241
movl %eax, %ebp
movl %eax, %r15d
leaq 0xb7e7b(%rip), %rax     # 0x1018a8
cmpq %r15, 0x950(%rax)
jae 0x4a007
callq 0x40a2e
movq %rax, %rbx
cmpl $0x5, %ebp
jb 0x4a00f
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x2e6fa
jmp 0x4a017
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x47db6
cmpl $-0x1, %eax
je 0x4a241
movl %eax, %ebp
callq 0x409c1
movq %rax, %rbx
movq 0x8(%rax), %rdi
leaq 0xb7e22(%rip), %rax     # 0x1018a8
movl 0x970(%rax), %esi
movl 0x974(%rax), %edx
callq 0x2b58c
testl %ebp, %ebp
je 0x4a241
movl %ebp, %r15d
movq %r14, %rdi
movl $0x2, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x2b9e4
decq %r15
jne 0x49aa2
jmp 0x4a241
leal -0x9(%rdx), %r15d
cmpl $0x4, %r15d
ja 0x4a2a4
movq %r14, %rdi
movl $0x2, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
xorl %edi, %edi
movq %rax, %rsi
callq 0x40650
movq %rax, %rbx
leaq 0x78dea(%rip), %rax     # 0xc28f0
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
callq 0x3ae98
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x3952a
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rax, %rdi
callq 0x3952f
xorl %r13d, %r13d
testq %rax, %rax
je 0x49bb5
movq %rax, %r12
leaq 0x20(%rsp), %rbp
leaq 0xc(%rsp), %r15
movl 0x1c(%rsp), %edx
cmpl %r13d, %edx
cmoval %edx, %r13d
movl 0xc(%rsp), %eax
cmpl %r13d, %eax
cmoval %eax, %r13d
movq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %ecx
callq 0x3b65e
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x3b65e
movq %rax, %r14
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
movq %rbp, %rcx
movq %r15, %r8
callq 0x3952f
movq %rax, %r12
testq %rax, %rax
jne 0x49b51
movl %r13d, %r13d
movq 0x8(%rbx), %rdi
callq 0x38413
movq %r14, 0x8(%rbx)
movb $0x54, (%rbx)
movq %rbx, %rdi
callq 0x55afa
leaq 0xb7cd4(%rip), %rcx     # 0x1018a8
cmpq 0x940(%rcx), %rax
ja 0x4a111
cmpq %r13, 0x948(%rcx)
jae 0x4a241
jmp 0x4a111
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x47db6
cmpl $-0x1, %eax
je 0x4a241
movl %eax, %ebp
callq 0x409c1
movq %rax, %rbx
movq 0x8(%rax), %rdi
leaq 0xb7c8b(%rip), %rax     # 0x1018a8
movl 0x970(%rax), %esi
movl 0x974(%rax), %edx
callq 0x2b58c
testl %ebp, %ebp
je 0x4a241
movl %ebp, %r13d
leaq 0x78c9c(%rip), %rbp     # 0xc28dc
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %r15
movq %rax, %rdi
callq 0x41026
movq %rax, %r12
movq 0x8(%rax), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x49c9c
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x49c9e
movq -0x11(%rsi), %rdx
jmp 0x49c9e
movzwl -0x5(%rsi), %edx
jmp 0x49c9e
movl -0x9(%rsi), %edx
jmp 0x49c9e
movzbl -0x3(%rsi), %edx
jmp 0x49c9e
xorl %edx, %edx
decq %r13
movq 0x8(%rbx), %rdi
callq 0x26e5b
movq %r12, %rdi
callq 0x40c8f
movq %r15, %rdi
callq 0x40c8f
testq %r13, %r13
jne 0x49c40
jmp 0x4a241
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x47db6
cmpl $-0x1, %eax
je 0x4a241
movl %eax, %ebp
callq 0x40ad6
movq %rax, %rbx
testl %ebp, %ebp
je 0x4a0b7
movq 0x8(%rbx), %r13
movl %ebp, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %rdi
callq 0x40e09
movq %rax, %r12
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x48883
cmpl $-0x1, %eax
je 0x4a23f
movl (%r12), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x49dac
movq 0x8(%r12), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x49dac
leaq 0x78b64(%rip), %rdi     # 0xc28b4
movslq (%rdi,%rdx,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
movl %ecx, %esi
shrl $0x3, %esi
jmp 0x49d75
movq -0x11(%rax), %rsi
jmp 0x49d75
movzwl -0x5(%rax), %esi
jmp 0x49d75
movl -0x9(%rax), %esi
jmp 0x49d75
movzbl -0x3(%rax), %esi
cmpq %r15, %rsi
jbe 0x49dac
movl %edx, %edx
leaq 0x78b45(%rip), %rsi     # 0xc28c8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
movq %rcx, %r15
jmp 0x49dac
movq -0x11(%rax), %r15
jmp 0x49dac
movzwl -0x5(%rax), %r15d
jmp 0x49dac
movl -0x9(%rax), %r15d
jmp 0x49dac
movzbl -0x3(%rax), %r15d
decq %rbp
movq 0x8(%r13), %rdi
movsd 0x10(%rsp), %xmm0
movq %r12, %rsi
callq 0x4feda
movq (%r13), %rdi
leaq 0x8(%rax), %rdx
movq %r12, %rsi
callq 0x2e9b8
movq %r12, %rdi
callq 0x407a8
testq %rbp, %rbp
jne 0x49cf4
jmp 0x4a0ba
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x47db6
cmpl $-0x1, %eax
je 0x4a241
movl %eax, %ebp
callq 0x40aa1
movq %rax, %rbx
leaq 0xb7a9b(%rip), %r13     # 0x1018a8
cmpq %rbp, 0x940(%r13)
jae 0x49e23
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5548c
movl $0xf0, %ecx
movl (%rbx), %eax
andl %ecx, %eax
cmpl $0x50, %eax
setne %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x4a1bc
decq %rbp
movq %rbp, %rax
movq %rax, %rbp
movq %r14, %rdi
xorl %esi, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %r15
movl (%rax), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x4a26d
movq %r14, %rdi
xorl %esi, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %r12
movl (%rax), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x4a282
movq 0x8(%r15), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x49ecd
leaq 0x789bc(%rip), %rcx     # 0xc2864
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x49ecf
movq -0x11(%rsi), %rdx
jmp 0x49ecf
movzwl -0x5(%rsi), %edx
jmp 0x49ecf
movl -0x9(%rsi), %edx
jmp 0x49ecf
movzbl -0x3(%rsi), %edx
jmp 0x49ecf
xorl %edx, %edx
movq 0x8(%rbx), %rdi
movl $0x1, %ecx
callq 0x3b65e
movq %rax, 0x8(%rbx)
movq 0x8(%r12), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x49f20
leaq 0x7897d(%rip), %rdi     # 0xc2878
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
shrl $0x3, %edx
jmp 0x49f22
movq -0x11(%rsi), %rdx
jmp 0x49f22
movzwl -0x5(%rsi), %edx
jmp 0x49f22
movl -0x9(%rsi), %edx
jmp 0x49f22
movzbl -0x3(%rsi), %edx
jmp 0x49f22
xorl %edx, %edx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x3b65e
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x49fa7
leaq 0x78940(%rip), %rsi     # 0xc288c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x49f6f
movq -0x11(%rax), %rcx
jmp 0x49f6f
movzwl -0x5(%rax), %ecx
jmp 0x49f6f
movl -0x9(%rax), %ecx
jmp 0x49f6f
movzbl -0x3(%rax), %ecx
movq 0x948(%r13), %rax
cmpq %rax, %rcx
ja 0x4a19f
movq 0x8(%r12), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %esi
andl $0x7, %esi
cmpl $0x4, %esi
ja 0x49fce
leaq 0x78907(%rip), %rdi     # 0xc28a0
movslq (%rdi,%rsi,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
shrl $0x3, %ecx
jmp 0x49fc5
movq 0x948(%r13), %rax
jmp 0x49f7f
movq -0x11(%rdx), %rcx
jmp 0x49fc5
movzwl -0x5(%rdx), %ecx
jmp 0x49fc5
movl -0x9(%rdx), %ecx
jmp 0x49fc5
movzbl -0x3(%rdx), %ecx
cmpq %rax, %rcx
ja 0x4a19f
movq %r15, %rdi
callq 0x40c8f
movq %r12, %rdi
callq 0x40c8f
movl (%rbx), %edx
movl $0xf0, %eax
andl %eax, %edx
movq %rbp, %rax
addq $-0x1, %rax
setb %cl
cmpl $0x50, %edx
jne 0x4a1bc
testb %cl, %cl
jne 0x49e46
jmp 0x4a1bc
callq 0x40a6c
movq %rax, %rbx
testl %ebp, %ebp
je 0x4a241
movl $0xf0, %r12d
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %rdi
callq 0x40e09
movq %rax, %r13
movl (%rbx), %eax
andl %r12d, %eax
cmpl $0x60, %eax
jne 0x4a088
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x40d6d
testl %eax, %eax
je 0x4a074
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4e16d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x2e6fa
jmp 0x4a088
movq 0x8(%rbx), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x64a18
movq %rax, 0x8(%rbx)
movl (%rbx), %eax
andl %r12d, %eax
cmpl $0x20, %eax
jne 0x4a0a2
movq 0x8(%rbx), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2e9b8
jmp 0x4a0aa
movq %r13, %rdi
callq 0x40c8f
decl %ebp
jne 0x4a01d
jmp 0x4a241
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x51a88
movl %eax, %ecx
leaq 0xb77dd(%rip), %rax     # 0x1018a8
cmpq %rcx, 0x958(%rax)
jb 0x4a241
cmpq 0x960(%rax), %r15
ja 0x4a241
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x4a180
movb $0x54, (%rbx)
movq %rbx, %rdi
callq 0x55afa
leaq 0xb77a4(%rip), %rcx     # 0x1018a8
cmpq 0x940(%rcx), %rax
jbe 0x4a241
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5548c
jmp 0x4a241
movb $0x62, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x64e5b
movl %eax, %eax
leaq 0xb7770(%rip), %rcx     # 0x1018a8
cmpq %rax, 0x950(%rcx)
jae 0x4a241
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4e16d
jmp 0x4a241
movb $0x53, (%rbx)
movq %rbx, %rdi
callq 0x51a88
movl %eax, %eax
leaq 0xb773d(%rip), %rcx     # 0x1018a8
cmpq %rax, 0x958(%rcx)
jae 0x4a241
movq %rbx, %rdi
movl $0x7, %esi
callq 0x51ad7
jmp 0x4a241
movb $0x51, (%rbx)
movq %rbx, %rdi
movl $0x9, %esi
callq 0x4c7bd
jmp 0x4a241
movq %r15, %rdi
callq 0x40c8f
movq %r12, %rdi
callq 0x40c8f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5548c
movq %rbp, %r13
movl (%rbx), %ecx
movl $0xf0, %eax
andl %eax, %ecx
addq $-0x1, %r13
setb %al
cmpl $0x20, %ecx
jne 0x4a253
testb %al, %al
je 0x4a253
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x4867f
testq %rax, %rax
je 0x4a23f
movq %rax, %r12
movq %r15, %rdi
callq 0x40e09
movq %rax, %r15
movq %r12, %rdi
callq 0x40e09
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2e9b8
movq %r13, %rbp
cmpl $0x1, %eax
jne 0x4a1bf
leaq 0x78a37(%rip), %rsi     # 0xc2c6a
movl $0x46c, %edi            # imm = 0x46C
xorl %eax, %eax
callq 0x47948
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rbp, %rbp
je 0x4a241
leaq 0x78a23(%rip), %rdi     # 0xc2c82
leaq 0x787a8(%rip), %rsi     # 0xc2a0e
movl $0x471, %edx            # imm = 0x471
jmp 0x4a295
leaq 0x789c6(%rip), %rdi     # 0xc2c3a
leaq 0x78793(%rip), %rsi     # 0xc2a0e
movl $0x446, %edx            # imm = 0x446
jmp 0x4a295
leaq 0x789c9(%rip), %rdi     # 0xc2c52
leaq 0x7877e(%rip), %rsi     # 0xc2a0e
movl $0x449, %edx            # imm = 0x449
callq 0x61908
movl $0x1, %edi
callq 0x263c0
leaq 0x789e0(%rip), %rsi     # 0xc2c8b
movl $0x4c7, %edi            # imm = 0x4C7
xorl %eax, %eax
callq 0x47948