// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zaddGenericCommand
void zaddGenericCommand(client *c, int flags) {
    static char *nanerr = "resulting score is not a number (NaN)";
    robj *key = c->argv[1];
    robj *ele;
    robj *zobj;
    robj *curobj;
    double score = 0, *scores = NULL, curscore = 0.0;
    int j, elements;
    int scoreidx = 0;
    /* The following vars are used in order to track what the command actually
     * did during the execution, to reply to the client and to trigger the
     * notification of keyspace change. */
    int added = 0;      /* Number of new elements added. */
    int updated = 0;    /* Number of elements with updated score. */
    int processed = 0;  /* Number of elements processed, may remain zero with
                           options like XX. */

    /* Parse options. At the end 'scoreidx' is set to the argument position
     * of the score of the first score-element pair. */
    scoreidx = 2;
    while(scoreidx < c->argc) {
        char *opt = c->argv[scoreidx]->ptr;
        if (!strcasecmp(opt,"nx")) flags |= ZADD_NX;
        else if (!strcasecmp(opt,"xx")) flags |= ZADD_XX;
        else if (!strcasecmp(opt,"ch")) flags |= ZADD_CH;
        else if (!strcasecmp(opt,"incr")) flags |= ZADD_INCR;
        else break;
        scoreidx++;
    }

    /* Turn options into simple to check vars. */
    int incr = (flags & ZADD_INCR) != 0;
    int nx = (flags & ZADD_NX) != 0;
    int xx = (flags & ZADD_XX) != 0;
    int ch = (flags & ZADD_CH) != 0;

    /* After the options, we expect to have an even number of args, since
     * we expect any number of score-element pairs. */
    elements = c->argc-scoreidx;
    if (elements % 2 || !elements) {
        addReply(c,shared.syntaxerr);
        return;
    }
    elements /= 2; /* Now this holds the number of score-element pairs. */

    /* Check for incompatible options. */
    if (nx && xx) {
        addReplyError(c,
            "XX and NX options at the same time are not compatible");
        return;
    }

    if (incr && elements > 1) {
        addReplyError(c,
            "INCR option supports a single increment-element pair");
        return;
    }

    /* Start parsing all the scores, we need to emit any syntax error
     * before executing additions to the sorted set, as the command should
     * either execute fully or nothing at all. */
    scores = zmalloc(sizeof(double)*elements);
    for (j = 0; j < elements; j++) {
        if (getDoubleFromObjectOrReply(c,c->argv[scoreidx+j*2],&scores[j],NULL)
            != C_OK) goto cleanup;
    }

    /* Lookup the key and create the sorted set if does not exist. */
    zobj = lookupKeyWrite(c->db,key);
    if (zobj == NULL) {
        if (xx) goto reply_to_client; /* No key + XX option: nothing to do. */
        if (server.zset_max_ziplist_entries == 0 ||
            server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+1]->ptr))
        {
            zobj = createZsetObject();
        } else {
            zobj = createZsetZiplistObject();
        }
        dbAdd(c->db,key,zobj);
    } else {
        if (zobj->type != OBJ_ZSET) {
            addReply(c,shared.wrongtypeerr);
            goto cleanup;
        }
    }

    for (j = 0; j < elements; j++) {
        score = scores[j];

        if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
            unsigned char *eptr;

            /* Prefer non-encoded element when dealing with ziplists. */
            ele = c->argv[scoreidx+1+j*2];
            if ((eptr = zzlFind(zobj->ptr,ele,&curscore)) != NULL) {
                if (nx) continue;
                if (incr) {
                    score += curscore;
                    if (isnan(score)) {
                        addReplyError(c,nanerr);
                        goto cleanup;
                    }
                }

                /* Remove and re-insert when score changed. */
                if (score != curscore) {
                    zobj->ptr = zzlDelete(zobj->ptr,eptr);
                    zobj->ptr = zzlInsert(zobj->ptr,ele,score);
                    server.dirty++;
                    updated++;
                }
                processed++;
            } else if (!xx) {
                /* Optimize: check if the element is too large or the list
                 * becomes too long *before* executing zzlInsert. */
                zobj->ptr = zzlInsert(zobj->ptr,ele,score);
                if (zzlLength(zobj->ptr) > server.zset_max_ziplist_entries)
                    zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
                if (sdslen(ele->ptr) > server.zset_max_ziplist_value)
                    zsetConvert(zobj,OBJ_ENCODING_SKIPLIST);
                server.dirty++;
                added++;
                processed++;
            }
        } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
            zset *zs = zobj->ptr;
            zskiplistNode *znode;
            dictEntry *de;

            ele = c->argv[scoreidx+1+j*2] =
                tryObjectEncoding(c->argv[scoreidx+1+j*2]);
            de = dictFind(zs->dict,ele);
            if (de != NULL) {
                if (nx) continue;
                curobj = dictGetKey(de);
                curscore = *(double*)dictGetVal(de);

                if (incr) {
                    score += curscore;
                    if (isnan(score)) {
                        addReplyError(c,nanerr);
                        /* Don't need to check if the sorted set is empty
                         * because we know it has at least one element. */
                        goto cleanup;
                    }
                }

                /* Remove and re-insert when score changed. We can safely
                 * delete the key object from the skiplist, since the
                 * dictionary still has a reference to it. */
                if (score != curscore) {
                    serverAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj));
                    znode = zslInsert(zs->zsl,score,curobj);
                    incrRefCount(curobj); /* Re-inserted in skiplist. */
                    dictGetVal(de) = &znode->score; /* Update score ptr. */
                    server.dirty++;
                    updated++;
                }
                processed++;
            } else if (!xx) {
                znode = zslInsert(zs->zsl,score,ele);
                incrRefCount(ele); /* Inserted in skiplist. */
                serverAssertWithInfo(c,NULL,dictAdd(zs->dict,ele,&znode->score) == DICT_OK);
                incrRefCount(ele); /* Added to dictionary. */
                server.dirty++;
                added++;
                processed++;
            }
        } else {
            serverPanic("Unknown sorted set encoding");
        }
    }

reply_to_client:
    if (incr) { /* ZINCRBY or INCR option. */
        if (processed)
            addReplyDouble(c,score);
        else
            addReply(c,shared.nullbulk);
    } else { /* ZADD. */
        addReplyLongLong(c,ch ? added+updated : added);
    }

cleanup:
    zfree(scores);
    if (added || updated) {
        signalModifiedKey(c->db,key);
        notifyKeyspaceEvent(NOTIFY_ZSET,
            incr ? "zincr" : "zadd", key, c->db->id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movl $0x2, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x6173b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
leaq 0xd60bd(%rip), %rsi     # 0x13776d
callq 0x26300
cmpl $0x0, %eax
jne 0x616c5
movl -0xc(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x6172d
movq -0x68(%rbp), %rdi
leaq 0xdc6c2(%rip), %rsi     # 0x13dd92
callq 0x26300
cmpl $0x0, %eax
jne 0x616e5
movl -0xc(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x6172b
movq -0x68(%rbp), %rdi
leaq 0xe9a39(%rip), %rsi     # 0x14b129
callq 0x26300
cmpl $0x0, %eax
jne 0x61705
movl -0xc(%rbp), %eax
orl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x61729
movq -0x68(%rbp), %rdi
leaq 0xdc743(%rip), %rsi     # 0x13de53
callq 0x26300
cmpl $0x0, %eax
jne 0x61725
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x61727
jmp 0x6173b
jmp 0x61729
jmp 0x6172b
jmp 0x6172d
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x6167d
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x6c(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x70(%rbp)
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl -0x54(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x617ae
cmpl $0x0, -0x50(%rbp)
jne 0x617ca
movq -0x8(%rbp), %rdi
leaq 0x117487(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x61eea
movl -0x50(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x70(%rbp)
je 0x617f9
cmpl $0x0, -0x74(%rbp)
je 0x617f9
movq -0x8(%rbp), %rdi
leaq 0xdc5a6(%rip), %rsi     # 0x13dd95
callq 0x42f90
jmp 0x61eea
cmpl $0x0, -0x6c(%rbp)
je 0x6181a
cmpl $0x1, -0x50(%rbp)
jle 0x6181a
movq -0x8(%rbp), %rdi
leaq 0xdc5bb(%rip), %rsi     # 0x13ddcb
callq 0x42f90
jmp 0x61eea
movslq -0x50(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3acd0
movq %rax, -0x40(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jge 0x61886
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x54(%rbp), %ecx
movl -0x4c(%rbp), %edx
shll %edx
addl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x40(%rbp), %rdx
movslq -0x4c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49b10
cmpl $0x0, %eax
je 0x61879
jmp 0x61e93
jmp 0x6187b
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x61832
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a6f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6192f
cmpl $0x0, -0x74(%rbp)
je 0x618b1
jmp 0x61e22
leaq 0x116920(%rip), %rax    # 0x1781d8
cmpq $0x0, 0x958(%rax)
je 0x61904
leaq 0x11690f(%rip), %rax    # 0x1781d8
movq 0x960(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x6190f
callq 0x48c90
movq %rax, -0x28(%rbp)
jmp 0x61918
callq 0x48d00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4a7d0
jmp 0x61958
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x3, %eax
je 0x61956
movq -0x8(%rbp), %rdi
leaq 0x1172f8(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
jmp 0x61e93
jmp 0x61958
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jge 0x61e20
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x61b5e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl -0x4c(%rbp), %edx
shll %edx
addl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x60970
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x61aa2
cmpl $0x0, -0x70(%rbp)
je 0x619e0
jmp 0x61e12
cmpl $0x0, -0x6c(%rbp)
je 0x61a1e
movsd -0x48(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x61a07
jmp 0x61a1c
movq -0x8(%rbp), %rdi
movq 0x1155ee(%rip), %rsi    # 0x177000
callq 0x42f90
jmp 0x61e93
jmp 0x61a1e
movsd -0x38(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jne 0x61a2e
jp 0x61a2e
jmp 0x61a94
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x80(%rbp), %rsi
callq 0x60a90
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
callq 0x60cc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x116766(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x116754(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x61b59
cmpl $0x0, -0x74(%rbp)
jne 0x61b57
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
callq 0x60cc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x600c0
movl %eax, %eax
leaq 0x1166f5(%rip), %rcx    # 0x1781d8
cmpq 0x958(%rcx), %rax
jbe 0x61afa
movq -0x28(%rbp), %rdi
movl $0x7, %esi
callq 0x610f0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
leaq 0x1166ca(%rip), %rcx    # 0x1781d8
cmpq 0x960(%rcx), %rax
jbe 0x61b25
movq -0x28(%rbp), %rdi
movl $0x7, %esi
callq 0x610f0
leaq 0x1166ac(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x11669a(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x61b59
jmp 0x61e10
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x7, %eax
jne 0x61dec
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl -0x4c(%rbp), %edx
shll %edx
addl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x491b0
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x54(%rbp), %edx
addl $0x1, %edx
movl -0x4c(%rbp), %esi
shll %esi
addl %esi, %edx
movslq %edx, %rdx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x20(%rbp)
movq -0x88(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2dcb0
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x61d2a
cmpl $0x0, -0x70(%rbp)
je 0x61bf6
jmp 0x61e12
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0x61c56
movsd -0x48(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x61c3f
jmp 0x61c54
movq -0x8(%rbp), %rdi
movq 0x1153b6(%rip), %rsi    # 0x177000
callq 0x42f90
jmp 0x61e93
jmp 0x61c56
movsd -0x38(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jne 0x61c69
jp 0x61c69
jmp 0x61d1c
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x48(%rbp), %xmm0
movq -0x30(%rbp), %rsi
callq 0x5e800
cmpl $0x0, %eax
je 0x61c89
jmp 0x61cb4
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0xdc168(%rip), %rdx     # 0x13de00
leaq 0xdbf83(%rip), %rcx     # 0x13dc22
movl $0x552, %r8d            # imm = 0x552
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rsi
callq 0x5e160
movq %rax, -0x90(%rbp)
movq -0x30(%rbp), %rdi
callq 0x487b0
movq -0x90(%rbp), %rcx
addq $0x8, %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x1164de(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x1164cc(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x61dea
cmpl $0x0, -0x74(%rbp)
jne 0x61de8
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rsi
callq 0x5e160
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x487b0
movq -0x88(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x90(%rbp), %rdx
addq $0x8, %rdx
callq 0x2d8c0
cmpl $0x0, %eax
jne 0x61d82
jmp 0x61dad
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xdc092(%rip), %rdx     # 0x13de23
leaq 0xdbe8a(%rip), %rcx     # 0x13dc22
movl $0x55d, %r8d            # imm = 0x55D
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rdi
callq 0x487b0
leaq 0x11641b(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x116409(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x61dea
jmp 0x61e0e
leaq 0xd98f7(%rip), %rdi     # 0x13b6ea
leaq 0xdbe28(%rip), %rsi     # 0x13dc22
movl $0x564, %edx            # imm = 0x564
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x61e10
jmp 0x61e12
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x6195f
jmp 0x61e22
cmpl $0x0, -0x6c(%rbp)
je 0x61e54
cmpl $0x0, -0x60(%rbp)
je 0x61e3e
movq -0x8(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x43480
jmp 0x61e52
movq -0x8(%rbp), %rdi
leaq 0x116df7(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x61e91
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpl $0x0, -0x78(%rbp)
je 0x61e73
movl -0x58(%rbp), %eax
addl -0x5c(%rbp), %eax
movl %eax, -0xac(%rbp)
jmp 0x61e7c
movl -0x58(%rbp), %eax
movl %eax, -0xac(%rbp)
movq -0xa8(%rbp), %rdi
movl -0xac(%rbp), %eax
movslq %eax, %rsi
callq 0x43780
jmp 0x61e93
movq -0x40(%rbp), %rdi
callq 0x3afa0
cmpl $0x0, -0x58(%rbp)
jne 0x61ea8
cmpl $0x0, -0x5c(%rbp)
je 0x61eea
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4aa60
movl -0x6c(%rbp), %ecx
leaq 0xd573d(%rip), %rsi     # 0x137600
leaq 0xdbf88(%rip), %rax     # 0x13de52
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x80, %edi
callq 0x9ce20
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)