// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zunionInterGenericCommand
void zunionInterGenericCommand(client *c, robj *dstkey, int op) {
    int i, j;
    long setnum;
    int aggregate = REDIS_AGGR_SUM;
    zsetopsrc *src;
    zsetopval zval;
    robj *tmp;
    unsigned int maxelelen = 0;
    robj *dstobj;
    zset *dstzset;
    zskiplistNode *znode;
    int touched = 0;

    /* expect setnum input keys to be given */
    if ((getLongFromObjectOrReply(c, c->argv[2], &setnum, NULL) != C_OK))
        return;

    if (setnum < 1) {
        addReplyError(c,
            "at least 1 input key is needed for ZUNIONSTORE/ZINTERSTORE");
        return;
    }

    /* test if the expected number of keys would overflow */
    if (setnum > c->argc-3) {
        addReply(c,shared.syntaxerr);
        return;
    }

    /* read keys to be used for input */
    src = zcalloc(sizeof(zsetopsrc) * setnum);
    for (i = 0, j = 3; i < setnum; i++, j++) {
        robj *obj = lookupKeyWrite(c->db,c->argv[j]);
        if (obj != NULL) {
            if (obj->type != OBJ_ZSET && obj->type != OBJ_SET) {
                zfree(src);
                addReply(c,shared.wrongtypeerr);
                return;
            }

            src[i].subject = obj;
            src[i].type = obj->type;
            src[i].encoding = obj->encoding;
        } else {
            src[i].subject = NULL;
        }

        /* Default all weights to 1. */
        src[i].weight = 1.0;
    }

    /* parse optional extra arguments */
    if (j < c->argc) {
        int remaining = c->argc - j;

        while (remaining) {
            if (remaining >= (setnum + 1) && !strcasecmp(c->argv[j]->ptr,"weights")) {
                j++; remaining--;
                for (i = 0; i < setnum; i++, j++, remaining--) {
                    if (getDoubleFromObjectOrReply(c,c->argv[j],&src[i].weight,
                            "weight value is not a float") != C_OK)
                    {
                        zfree(src);
                        return;
                    }
                }
            } else if (remaining >= 2 && !strcasecmp(c->argv[j]->ptr,"aggregate")) {
                j++; remaining--;
                if (!strcasecmp(c->argv[j]->ptr,"sum")) {
                    aggregate = REDIS_AGGR_SUM;
                } else if (!strcasecmp(c->argv[j]->ptr,"min")) {
                    aggregate = REDIS_AGGR_MIN;
                } else if (!strcasecmp(c->argv[j]->ptr,"max")) {
                    aggregate = REDIS_AGGR_MAX;
                } else {
                    zfree(src);
                    addReply(c,shared.syntaxerr);
                    return;
                }
                j++; remaining--;
            } else {
                zfree(src);
                addReply(c,shared.syntaxerr);
                return;
            }
        }
    }

    /* sort sets from the smallest to largest, this will improve our
     * algorithm's performance */
    qsort(src,setnum,sizeof(zsetopsrc),zuiCompareByCardinality);

    dstobj = createZsetObject();
    dstzset = dstobj->ptr;
    memset(&zval, 0, sizeof(zval));

    if (op == SET_OP_INTER) {
        /* Skip everything if the smallest input is empty. */
        if (zuiLength(&src[0]) > 0) {
            /* Precondition: as src[0] is non-empty and the inputs are ordered
             * by size, all src[i > 0] are non-empty too. */
            zuiInitIterator(&src[0]);
            while (zuiNext(&src[0],&zval)) {
                double score, value;

                score = src[0].weight * zval.score;
                if (isnan(score)) score = 0;

                for (j = 1; j < setnum; j++) {
                    /* It is not safe to access the zset we are
                     * iterating, so explicitly check for equal object. */
                    if (src[j].subject == src[0].subject) {
                        value = zval.score*src[j].weight;
                        zunionInterAggregate(&score,value,aggregate);
                    } else if (zuiFind(&src[j],&zval,&value)) {
                        value *= src[j].weight;
                        zunionInterAggregate(&score,value,aggregate);
                    } else {
                        break;
                    }
                }

                /* Only continue when present in every input. */
                if (j == setnum) {
                    tmp = zuiObjectFromValue(&zval);
                    znode = zslInsert(dstzset->zsl,score,tmp);
                    incrRefCount(tmp); /* added to skiplist */
                    dictAdd(dstzset->dict,tmp,&znode->score);
                    incrRefCount(tmp); /* added to dictionary */

                    if (sdsEncodedObject(tmp)) {
                        if (sdslen(tmp->ptr) > maxelelen)
                            maxelelen = sdslen(tmp->ptr);
                    }
                }
            }
            zuiClearIterator(&src[0]);
        }
    } else if (op == SET_OP_UNION) {
        dict *accumulator = dictCreate(&setDictType,NULL);
        dictIterator *di;
        dictEntry *de;
        double score;

        if (setnum) {
            /* Our union is at least as large as the largest set.
             * Resize the dictionary ASAP to avoid useless rehashing. */
            dictExpand(accumulator,zuiLength(&src[setnum-1]));
        }

        /* Step 1: Create a dictionary of elements -> aggregated-scores
         * by iterating one sorted set after the other. */
        for (i = 0; i < setnum; i++) {
            if (zuiLength(&src[i]) == 0) continue;

            zuiInitIterator(&src[i]);
            while (zuiNext(&src[i],&zval)) {
                /* Initialize value */
                score = src[i].weight * zval.score;
                if (isnan(score)) score = 0;

                /* Search for this element in the accumulating dictionary. */
                de = dictFind(accumulator,zuiObjectFromValue(&zval));
                /* If we don't have it, we need to create a new entry. */
                if (de == NULL) {
                    tmp = zuiObjectFromValue(&zval);
                    /* Remember the longest single element encountered,
                     * to understand if it's possible to convert to ziplist
                     * at the end. */
                    if (sdsEncodedObject(tmp)) {
                        if (sdslen(tmp->ptr) > maxelelen)
                            maxelelen = sdslen(tmp->ptr);
                    }
                    /* Add the element with its initial score. */
                    de = dictAddRaw(accumulator,tmp);
                    incrRefCount(tmp);
                    dictSetDoubleVal(de,score);
                } else {
                    /* Update the score with the score of the new instance
                     * of the element found in the current sorted set.
                     *
                     * Here we access directly the dictEntry double
                     * value inside the union as it is a big speedup
                     * compared to using the getDouble/setDouble API. */
                    zunionInterAggregate(&de->v.d,score,aggregate);
                }
            }
            zuiClearIterator(&src[i]);
        }

        /* Step 2: convert the dictionary into the final sorted set. */
        di = dictGetIterator(accumulator);

        /* We now are aware of the final size of the resulting sorted set,
         * let's resize the dictionary embedded inside the sorted set to the
         * right size, in order to save rehashing time. */
        dictExpand(dstzset->dict,dictSize(accumulator));

        while((de = dictNext(di)) != NULL) {
            robj *ele = dictGetKey(de);
            score = dictGetDoubleVal(de);
            znode = zslInsert(dstzset->zsl,score,ele);
            incrRefCount(ele); /* added to skiplist */
            dictAdd(dstzset->dict,ele,&znode->score);
            incrRefCount(ele); /* added to dictionary */
        }
        dictReleaseIterator(di);

        /* We can free the accumulator dictionary now. */
        dictRelease(accumulator);
    } else {
        serverPanic("Unknown operator");
    }

    if (dbDelete(c->db,dstkey))
        touched = 1;
    if (dstzset->zsl->length) {
        zsetConvertToZiplistIfNeeded(dstobj,maxelelen);
        dbAdd(c->db,dstkey,dstobj);
        addReplyLongLong(c,zsetLength(dstobj));
        signalModifiedKey(c->db,dstkey);
        notifyKeyspaceEvent(NOTIFY_ZSET,
            (op == SET_OP_UNION) ? "zunionstore" : "zinterstore",
            dstkey,c->db->id);
        server.dirty++;
    } else {
        decrRefCount(dstobj);
        addReply(c,shared.czero);
        if (touched) {
            signalModifiedKey(c->db,dstkey);
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",dstkey,c->db->id);
            server.dirty++;
        }
    }
    zfree(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x94(%rbp)
movl $0x0, -0xb4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49f20
cmpl $0x0, %eax
je 0x637b8
jmp 0x642ed
cmpq $0x1, -0x28(%rbp)
jge 0x637d4
movq -0x8(%rbp), %rdi
leaq 0xda771(%rip), %rsi     # 0x13df3b
callq 0x42f90
jmp 0x642ed
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x63806
movq -0x8(%rbp), %rdi
leaq 0x11544b(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x642ed
imulq $0x30, -0x28(%rbp), %rdi
callq 0x3ad80
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
movslq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x63949
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4a6f0
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0xc0(%rbp)
je 0x63900
movq -0xc0(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
je 0x638a6
movq -0xc0(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x638a6
movq -0x38(%rbp), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
leaq 0x1153a8(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
jmp 0x642ed
movq -0xc0(%rbp), %rcx
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0xc0(%rbp), %rax
movl (%rax), %ecx
andl $0xf, %ecx
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0xc0(%rbp), %rax
movl (%rax), %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
jmp 0x63916
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0xd3b3b(%rip), %xmm0    # 0x137468
movsd %xmm0, 0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x63822
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x63b9c
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
je 0x63b9a
movslq -0xc4(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jl 0x63a50
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xda5cd(%rip), %rsi     # 0x13df76
callq 0x26300
cmpl $0x0, %eax
jne 0x63a50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc4(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x63a4b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x38(%rbp), %rdx
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
addq $0x10, %rdx
leaq 0xda570(%rip), %rcx     # 0x13df7e
callq 0x49b10
cmpl $0x0, %eax
je 0x63a26
movq -0x38(%rbp), %rdi
callq 0x3afa0
jmp 0x642ed
jmp 0x63a28
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x639d6
jmp 0x63b95
cmpl $0x2, -0xc4(%rbp)
jl 0x63b6e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xda522(%rip), %rsi     # 0x13df9a
callq 0x26300
cmpl $0x0, %eax
jne 0x63b6e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc4(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xe5621(%rip), %rsi     # 0x1490da
callq 0x26300
cmpl $0x0, %eax
jne 0x63acf
movl $0x1, -0x2c(%rbp)
jmp 0x63b54
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xd4d6f(%rip), %rsi     # 0x138859
callq 0x26300
cmpl $0x0, %eax
jne 0x63afd
movl $0x2, -0x2c(%rbp)
jmp 0x63b52
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xea4d2(%rip), %rsi     # 0x14dfea
callq 0x26300
cmpl $0x0, %eax
jne 0x63b2b
movl $0x3, -0x2c(%rbp)
jmp 0x63b50
movq -0x38(%rbp), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
leaq 0x115101(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x642ed
jmp 0x63b52
jmp 0x63b54
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x63b93
movq -0x38(%rbp), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
leaq 0x1150be(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x642ed
jmp 0x63b95
jmp 0x63969
jmp 0x63b9c
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x30, %edx
leaq -0x490(%rip), %rcx      # 0x63720
callq 0x26890
callq 0x48c90
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x26110
cmpl $0x2, -0x14(%rbp)
jne 0x63e2c
movq -0x38(%rbp), %rdi
callq 0x62da0
cmpl $0x0, %eax
jle 0x63e27
movq -0x38(%rbp), %rdi
callq 0x62a90
movq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x62ef0
cmpl $0x0, %eax
je 0x63e1e
movq -0x38(%rbp), %rax
movsd 0x10(%rax), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movsd -0xd0(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x63c4f
jmp 0x63c5a
xorps %xmm0, %xmm0
movsd %xmm0, -0xd0(%rbp)
movl $0x1, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x63d3c
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x63cc4
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm0
movl -0x2c(%rbp), %esi
leaq -0xd0(%rbp), %rdi
callq 0x64300
jmp 0x63d2c
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x88(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x63500
cmpl $0x0, %eax
je 0x63d28
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
mulsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm0
movl -0x2c(%rbp), %esi
leaq -0xd0(%rbp), %rdi
callq 0x64300
jmp 0x63d2a
jmp 0x63d3c
jmp 0x63d2c
jmp 0x63d2e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x63c61
movslq -0x1c(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x63e19
leaq -0x88(%rbp), %rdi
callq 0x63340
movq %rax, -0x90(%rbp)
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0xd0(%rbp), %xmm0
movq -0x90(%rbp), %rsi
callq 0x5e160
movq %rax, -0xb0(%rbp)
movq -0x90(%rbp), %rdi
callq 0x487b0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movq -0x90(%rbp), %rsi
movq -0xb0(%rbp), %rdx
addq $0x8, %rdx
callq 0x2d8c0
movq -0x90(%rbp), %rdi
callq 0x487b0
movq -0x90(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x63de4
movq -0x90(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x63e17
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movl -0x94(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x63e15
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movl %eax, -0x94(%rbp)
jmp 0x63e17
jmp 0x63e19
jmp 0x63c0b
movq -0x38(%rbp), %rdi
callq 0x62ca0
jmp 0x6417b
cmpl $0x0, -0x14(%rbp)
jne 0x64157
leaq 0x112f73(%rip), %rdi    # 0x176db0
xorl %eax, %eax
movl %eax, %esi
callq 0x2d330
movq %rax, -0xe0(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x63e89
movq -0xe0(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
subq $0x1, %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x62da0
movq -0x108(%rbp), %rdi
movslq %eax, %rsi
callq 0x2d440
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x6405f
movq -0x38(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x62da0
cmpl $0x0, %eax
jne 0x63ebc
jmp 0x64051
movq -0x38(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x62a90
movq -0x38(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x62ef0
cmpl $0x0, %eax
je 0x6403d
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
movsd -0xf8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x63f2a
jmp 0x63f35
xorps %xmm0, %xmm0
movsd %xmm0, -0xf8(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x63340
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x2dcb0
movq %rax, -0xf0(%rbp)
cmpq $0x0, -0xf0(%rbp)
jne 0x6401d
leaq -0x88(%rbp), %rdi
callq 0x63340
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x63fae
movq -0x90(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x63fe1
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movl -0x94(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x63fdf
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movl %eax, -0x94(%rbp)
jmp 0x63fe1
movq -0xe0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x2d950
movq %rax, -0xf0(%rbp)
movq -0x90(%rbp), %rdi
callq 0x487b0
movsd -0xf8(%rbp), %xmm0
movq -0xf0(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x64038
movq -0xf0(%rbp), %rdi
addq $0x8, %rdi
movsd -0xf8(%rbp), %xmm0
movl -0x2c(%rbp), %esi
callq 0x64300
jmp 0x63ed0
movq -0x38(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x62ca0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x63e90
movq -0xe0(%rbp), %rdi
callq 0x2e400
movq %rax, -0xe8(%rbp)
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movq -0xe0(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0xe0(%rbp), %rax
addq 0x48(%rax), %rsi
callq 0x2d440
movq -0xe8(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0xf0(%rbp)
cmpq $0x0, %rax
je 0x6413d
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movq -0xf0(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xf8(%rbp)
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0xf8(%rbp), %xmm0
movq -0x100(%rbp), %rsi
callq 0x5e160
movq %rax, -0xb0(%rbp)
movq -0x100(%rbp), %rdi
callq 0x487b0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movq -0x100(%rbp), %rsi
movq -0xb0(%rbp), %rdx
addq $0x8, %rdx
callq 0x2d8c0
movq -0x100(%rbp), %rdi
callq 0x487b0
jmp 0x64097
movq -0xe8(%rbp), %rdi
callq 0x2e600
movq -0xe0(%rbp), %rdi
callq 0x2e230
jmp 0x64179
leaq 0xd9e46(%rip), %rdi     # 0x13dfa4
leaq 0xd9abd(%rip), %rsi     # 0x13dc22
movl $0x864, %edx            # imm = 0x864
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x6417b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4ac10
cmpl $0x0, %eax
je 0x6419b
movl $0x1, -0xb4(%rbp)
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x64268
movq -0xa0(%rbp), %rdi
movl -0x94(%rbp), %eax
movl %eax, %esi
callq 0x614a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x4a7d0
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x61060
movq -0x118(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x43780
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4aa60
movl -0x14(%rbp), %ecx
leaq 0xd342f(%rip), %rsi     # 0x13764e
leaq 0xd341c(%rip), %rax     # 0x137642
cmpl $0x0, %ecx
cmoveq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x80, %edi
callq 0x9ce20
leaq 0x113f8b(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x113f79(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
jmp 0x642e4
movq -0xa0(%rbp), %rdi
callq 0x48f70
movq -0x8(%rbp), %rdi
leaq 0x1149c1(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rsi
callq 0x42cc0
cmpl $0x0, -0xb4(%rbp)
je 0x642e2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4aa60
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0xd51db(%rip), %rsi     # 0x139498
callq 0x9ce20
leaq 0x113f0f(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x113efd(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
jmp 0x642e4
movq -0x38(%rbp), %rdi
callq 0x3afa0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)