LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslDelete
int zslDelete(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward &&
            (x->level[i].forward->score < score ||
                (x->level[i].forward->score == score &&
                compareStringObjects(x->level[i].forward->obj,obj) < 0)))
            x = x->level[i].forward;
        update[i] = x;
    }
    /* We may have multiple elements with the same score, what we need
     * is to find the element with both the right score and object. */
    x = x->level[0].forward;
    if (x && score == x->score && equalStringObjects(x->obj,obj)) {
        zslDeleteNode(zsl, x, update);
        zslFreeNode(x);
        return 1;
    }
    return 0; /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
movq (%rdi), %r15
movq %rdi, (%rsp)
movslq 0x18(%rdi), %r12
testq %r12, %r12
jle 0x5399b
movsd %xmm0, 0x8(%rsp)
movq %r12, %r13
decq %r12
movq %r12, %rbp
shlq $0x4, %rbp
movq 0x18(%r15,%rbp), %rax
testq %rax, %rax
je 0x53990
leaq (%r15,%rbp), %rbx
addq $0x18, %rbx
movsd 0x8(%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x5397d
ucomisd %xmm0, %xmm1
jne 0x53990
jp 0x53990
movq (%rax), %rdi
movq %r14, %rsi
callq 0x446ab
movsd 0x8(%rsp), %xmm0
testl %eax, %eax
jns 0x53990
movq (%rbx), %r15
leaq (%r15,%rbp), %rbx
addq $0x18, %rbx
movq (%rbx), %rax
testq %rax, %rax
jne 0x53955
movq %r15, 0x10(%rsp,%r12,8)
cmpq $0x1, %r13
jg 0x53936
movq 0x18(%r15), %r15
xorl %ebp, %ebp
testq %r15, %r15
je 0x539e9
movsd 0x8(%r15), %xmm1
ucomisd %xmm0, %xmm1
jne 0x539e9
jp 0x539e9
movq (%r15), %rdi
movq %r14, %rsi
callq 0x446bf
testl %eax, %eax
je 0x539e9
leaq 0x10(%rsp), %rdx
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x53869
movq (%r15), %rdi
callq 0x440f3
movq %r15, %rdi
callq 0x3b3df
movl $0x1, %ebp
movl %ebp, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslFirstInRange
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

    /* If everything is out of range, return early. */
    if (!zslIsInRange(zsl,range)) return NULL;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* Go forward while *OUT* of range. */
        while (x->level[i].forward &&
            !zslValueGteMin(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }

    /* This is an inner range, so the next node cannot be NULL. */
    x = x->level[0].forward;
    serverAssert(x != NULL);

    /* Check if score <= max. */
    if (!zslValueLteMax(x->score,range)) return NULL;
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x53a1b
testl %eax, %eax
je 0x53b23
movq (%r14), %rax
movslq 0x18(%r14), %rcx
testq %rcx, %rcx
jle 0x53af5
movq %rcx, %rdx
decq %rcx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
movq %rdi, %rax
movq 0x18(%rdi,%rsi), %rdi
testq %rdi, %rdi
je 0x53aef
movsd 0x8(%rdi), %xmm0
xorl %r8d, %r8d
xorl %r9d, %r9d
ucomisd (%rbx), %xmm0
seta %r8b
setae %r9b
cmpl $0x0, 0x10(%rbx)
cmovel %r9d, %r8d
cmpb $0x1, %r8b
jne 0x53abd
cmpq $0x1, %rdx
jg 0x53aad
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x53b2d
movsd 0x8(%rbx), %xmm0
xorl %edx, %edx
xorl %eax, %eax
ucomisd 0x8(%rcx), %xmm0
seta %dl
setae %al
cmpl $0x0, 0x14(%rbx)
cmovel %eax, %edx
xorl %eax, %eax
testb %dl, %dl
cmovneq %rcx, %rax
jmp 0x53b25
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x72b2b(%rip), %rdi     # 0xc665f
leaq 0x72b1b(%rip), %rsi     # 0xc6656
movl $0x100, %edx            # imm = 0x100
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslLastInRange
zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

    /* If everything is out of range, return early. */
    if (!zslIsInRange(zsl,range)) return NULL;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        /* Go forward while *IN* range. */
        while (x->level[i].forward &&
            zslValueLteMax(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }

    /* This is an inner range, so this node cannot be NULL. */
    serverAssert(x != NULL);

    /* Check if score >= min. */
    if (!zslValueGteMin(x->score,range)) return NULL;
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x53a1b
testl %eax, %eax
je 0x53bea
movq (%r14), %rcx
movslq 0x18(%r14), %rax
testq %rax, %rax
jle 0x53bc1
movq %rax, %rdx
decq %rax
movq %rax, %rsi
shlq $0x4, %rsi
movq %rcx, %rdi
movq %rdi, %rcx
movq 0x18(%rdi,%rsi), %rdi
testq %rdi, %rdi
je 0x53bbb
movsd 0x8(%rdi), %xmm0
cmpl $0x0, 0x14(%rbx)
je 0x53ba9
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
seta %r8b
jmp 0x53bb6
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %r8b
testb %r8b, %r8b
jne 0x53b82
cmpq $0x1, %rdx
jg 0x53b72
testq %rcx, %rcx
je 0x53bf4
movsd 0x8(%rcx), %xmm0
xorl %edx, %edx
xorl %eax, %eax
ucomisd (%rbx), %xmm0
seta %dl
setae %al
cmpl $0x0, 0x10(%rbx)
cmovel %eax, %edx
xorl %eax, %eax
testb %dl, %dl
cmovneq %rcx, %rax
jmp 0x53bec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x72a64(%rip), %rdi     # 0xc665f
leaq 0x72a54(%rip), %rsi     # 0xc6656
movl $0x119, %edx            # imm = 0x119
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslParseLexRangeItem
int zslParseLexRangeItem(robj *item, robj **dest, int *ex) {
    char *c = item->ptr;

    switch(c[0]) {
    case '+':
        if (c[1] != '\0') return C_ERR;
        *ex = 0;
        *dest = shared.maxstring;
        incrRefCount(shared.maxstring);
        return C_OK;
    case '-':
        if (c[1] != '\0') return C_ERR;
        *ex = 0;
        *dest = shared.minstring;
        incrRefCount(shared.minstring);
        return C_OK;
    case '(':
        *ex = 1;
        *dest = createStringObject(c+1,sdslen(c)-1);
        return C_OK;
    case '[':
        *ex = 0;
        *dest = createStringObject(c+1,sdslen(c)-1);
        return C_OK;
    default:
        return C_ERR;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rax
movzbl (%rax), %ecx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x2c, %ecx
jg 0x5409a
cmpl $0x28, %ecx
je 0x540d7
cmpl $0x2b, %ecx
jne 0x54159
cmpb $0x0, 0x1(%rax)
jne 0x54159
movl $0x0, (%rdx)
leaq 0xb322c(%rip), %rax     # 0x1072b0
movq 0x158(%rax), %rcx
movq %rcx, (%rbx)
movq 0x158(%rax), %rdi
jmp 0x5412b
cmpl $0x2d, %ecx
je 0x54107
cmpl $0x5b, %ecx
jne 0x54159
movl $0x0, (%rdx)
leaq 0x1(%rax), %rdi
movzbl -0x1(%rax), %esi
movl %esi, %ecx
andl $0x7, %ecx
xorl %r14d, %r14d
cmpl $0x4, %ecx
ja 0x5414c
leaq 0x72442(%rip), %rdx     # 0xc6510
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, (%rdx)
leaq 0x1(%rax), %rdi
movzbl -0x1(%rax), %esi
movl %esi, %ecx
andl $0x7, %ecx
xorl %r14d, %r14d
cmpl $0x4, %ecx
ja 0x5414c
leaq 0x7242b(%rip), %rdx     # 0xc6524
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %esi
jmp 0x5414e
cmpb $0x0, 0x1(%rax)
jne 0x54159
movl $0x0, (%rdx)
leaq 0xb3196(%rip), %rax     # 0x1072b0
movq 0x150(%rax), %rcx
movq %rcx, (%rbx)
movq 0x150(%rax), %rdi
callq 0x43c0c
xorl %r14d, %r14d
jmp 0x54159
movq -0x11(%rax), %rsi
jmp 0x5414e
movzwl -0x5(%rax), %esi
jmp 0x5414e
movl -0x9(%rax), %esi
jmp 0x5414e
movzbl -0x3(%rax), %esi
jmp 0x5414e
xorl %esi, %esi
decq %rsi
callq 0x43ba8
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlGetScore
double zzlGetScore(unsigned char *sptr) {
    unsigned char *vstr;
    unsigned int vlen;
    long long vlong;
    char buf[128];
    double score;

    serverAssert(sptr != NULL);
    serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong));

    if (vstr) {
        memcpy(buf,vstr,vlen);
        buf[vlen] = '\0';
        score = strtod(buf,NULL);
    } else {
        score = vlong;
    }

    return score;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
testq %rdi, %rdi
je 0x5447f
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x3eb60
testl %eax, %eax
je 0x54494
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x5446d
movl 0xc(%rsp), %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x26c60
movb $0x0, 0x20(%rsp,%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x26cd0
jmp 0x54474
cvtsi2sdq 0x10(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
leaq 0x72580(%rip), %rdi     # 0xc6a06
leaq 0x721c9(%rip), %rsi     # 0xc6656
movl $0x282, %edx            # imm = 0x282
jmp 0x544a7
leaq 0x721ce(%rip), %rdi     # 0xc6669
leaq 0x721b4(%rip), %rsi     # 0xc6656
movl $0x283, %edx            # imm = 0x283
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: ziplistGetObject
robj *ziplistGetObject(unsigned char *sptr) {
    unsigned char *vstr;
    unsigned int vlen;
    long long vlong;

    serverAssert(sptr != NULL);
    serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong));

    if (vstr) {
        return createStringObject((char*)vstr,vlen);
    } else {
        return createStringObjectFromLongLong(vlong);
    }
}

// Assembly:
subq $0x18, %rsp
testq %rdi, %rdi
je 0x544fb
leaq 0x10(%rsp), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x3eb60
testl %eax, %eax
je 0x54510
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x544ec
movl 0x4(%rsp), %esi
callq 0x43ba8
jmp 0x544f6
movq 0x8(%rsp), %rdi
callq 0x43bb7
addq $0x18, %rsp
retq
leaq 0x72504(%rip), %rdi     # 0xc6a06
leaq 0x7214d(%rip), %rsi     # 0xc6656
movl $0x298, %edx            # imm = 0x298
jmp 0x54523
leaq 0x72152(%rip), %rdi     # 0xc6669
leaq 0x72138(%rip), %rsi     # 0xc6656
movl $0x299, %edx            # imm = 0x299
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlNext
void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
    unsigned char *_eptr, *_sptr;
    serverAssert(*eptr != NULL && *sptr != NULL);

    _eptr = ziplistNext(zl,*sptr);
    if (_eptr != NULL) {
        _sptr = ziplistNext(zl,_eptr);
        serverAssert(_sptr != NULL);
    } else {
        /* No next entry. */
        _sptr = NULL;
    }

    *eptr = _eptr;
    *sptr = _sptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, (%rsi)
je 0x5463c
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x5463c
movq %rdi, %r12
callq 0x3ead6
movq %rax, %r15
testq %rax, %rax
je 0x54628
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ead6
testq %rax, %rax
jne 0x5462a
leaq 0x720b6(%rip), %rdi     # 0xc66d0
leaq 0x72035(%rip), %rsi     # 0xc6656
movl $0x2c4, %edx            # imm = 0x2C4
jmp 0x5464f
xorl %eax, %eax
movq %r15, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7206e(%rip), %rdi     # 0xc66b1
leaq 0x7200c(%rip), %rsi     # 0xc6656
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlFirstInRange
unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range) {
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double score;

    /* If everything is out of range, return early. */
    if (!zzlIsInRange(zl,range)) return NULL;

    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr);
        serverAssert(sptr != NULL);

        score = zzlGetScore(sptr);
        if (zslValueGteMin(score,range)) {
            /* Check if score <= max. */
            if (zslValueLteMax(score,range))
                return eptr;
            return NULL;
        }

        /* Move to next element. */
        eptr = ziplistNext(zl,sptr);
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x3ea40
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x546e5
testl %eax, %eax
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x54849
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ead6
testq %rax, %rax
je 0x54856
movq %rax, %r13
movq %rax, %rdi
callq 0x54417
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd (%r14), %xmm0
seta %al
setae %cl
cmpl $0x0, 0x10(%r14)
cmovel %ecx, %eax
cmpb $0x1, %al
je 0x54825
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ead6
movq %rax, %r15
testq %rax, %rax
jne 0x547da
jmp 0x54849
movsd 0x8(%r14), %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %al
setae %cl
cmpl $0x0, 0x14(%r14)
cmovel %ecx, %eax
xorl %ebx, %ebx
testb %al, %al
cmovneq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x721a9(%rip), %rdi     # 0xc6a06
leaq 0x71df2(%rip), %rsi     # 0xc6656
movl $0x306, %edx            # imm = 0x306
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlLastInRange
unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range) {
    unsigned char *eptr = ziplistIndex(zl,-2), *sptr;
    double score;

    /* If everything is out of range, return early. */
    if (!zzlIsInRange(zl,range)) return NULL;

    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr);
        serverAssert(sptr != NULL);

        score = zzlGetScore(sptr);
        if (zslValueLteMax(score,range)) {
            /* Check if score >= min. */
            if (zslValueGteMin(score,range))
                return eptr;
            return NULL;
        }

        /* Move to previous element by moving to the score of previous element.
         * When this returns NULL, we know there also is no element. */
        sptr = ziplistPrev(zl,eptr);
        if (sptr != NULL)
            serverAssert((eptr = ziplistPrev(zl,sptr)) != NULL);
        else
            eptr = NULL;
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x3ea40
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x546e5
testl %eax, %eax
sete %al
testq %r15, %r15
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x54941
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ead6
testq %rax, %rax
je 0x54950
movq %rax, %rdi
callq 0x54417
cmpl $0x0, 0x14(%rbx)
je 0x548e4
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x548f0
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %al
testb %al, %al
jne 0x54923
movq %r14, %rdi
movq %r15, %rsi
callq 0x3eafc
testq %rax, %rax
je 0x54919
movq %r14, %rdi
movq %rax, %rsi
callq 0x3eafc
movq %rax, %r15
testq %rax, %rax
jne 0x5491c
jmp 0x54965
xorl %r15d, %r15d
testq %r15, %r15
jne 0x548b4
jmp 0x54941
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd (%rbx), %xmm0
seta %al
setae %cl
cmpl $0x0, 0x10(%rbx)
cmovel %ecx, %eax
xorl %r12d, %r12d
testb %al, %al
cmovneq %r15, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x720af(%rip), %rdi     # 0xc6a06
leaq 0x71cf8(%rip), %rsi     # 0xc6656
movl $0x322, %edx            # imm = 0x322
jmp 0x54978
leaq 0x71d8a(%rip), %rdi     # 0xc66f6
leaq 0x71ce3(%rip), %rsi     # 0xc6656
movl $0x330, %edx            # imm = 0x330
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlInsertAt
unsigned char *zzlInsertAt(unsigned char *zl, unsigned char *eptr, robj *ele, double score) {
    unsigned char *sptr;
    char scorebuf[128];
    int scorelen;
    size_t offset;

    serverAssertWithInfo(NULL,ele,sdsEncodedObject(ele));
    scorelen = d2string(scorebuf,sizeof(scorebuf),score);
    if (eptr == NULL) {
        zl = ziplistPush(zl,ele->ptr,sdslen(ele->ptr),ZIPLIST_TAIL);
        zl = ziplistPush(zl,(unsigned char*)scorebuf,scorelen,ZIPLIST_TAIL);
    } else {
        /* Keep offset relative to zl, as it might be re-allocated. */
        offset = eptr-zl;
        zl = ziplistInsert(zl,eptr,ele->ptr,sdslen(ele->ptr));
        eptr = zl+offset;

        /* Insert score after the element. */
        serverAssertWithInfo(NULL,ele,(sptr = ziplistNext(zl,eptr)) != NULL);
        zl = ziplistInsert(zl,sptr,(unsigned char*)scorebuf,scorelen);
    }

    return zl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movl (%rdx), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x54e92
movq %rsi, %r12
movq %rdi, %r14
movq %rsp, %rdi
movl $0x80, %esi
callq 0x435e0
movl %eax, %ebx
testq %r12, %r12
je 0x54dbb
movq %r12, %r13
subq %r14, %r13
movq 0x8(%r15), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x54df9
leaq 0x717b3(%rip), %rsi     # 0xc6560
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
shrl $0x3, %ecx
jmp 0x54dfb
movq 0x8(%r15), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x54e45
leaq 0x717a0(%rip), %rcx     # 0xc6574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x54e47
movq -0x11(%rdx), %rcx
jmp 0x54dfb
movzwl -0x5(%rdx), %ecx
jmp 0x54dfb
movl -0x9(%rdx), %ecx
jmp 0x54dfb
movzbl -0x3(%rdx), %ecx
jmp 0x54dfb
xorl %ecx, %ecx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3ebf0
movq %rax, %r14
addq %rax, %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3ead6
testq %rax, %rax
je 0x54e77
movq %rsp, %rdx
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %ecx
callq 0x3ebf0
jmp 0x54e66
movq -0x11(%rsi), %rdx
jmp 0x54e47
movzwl -0x5(%rsi), %edx
jmp 0x54e47
movl -0x9(%rsi), %edx
jmp 0x54e47
movzbl -0x3(%rsi), %edx
jmp 0x54e47
xorl %edx, %edx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x3ea1e
movq %rsp, %rsi
movq %rax, %rdi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x3ea1e
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x718b4(%rip), %rdx     # 0xc6732
leaq 0x717d1(%rip), %rcx     # 0xc6656
xorl %edi, %edi
movq %r15, %rsi
movl $0x3c7, %r8d            # imm = 0x3C7
jmp 0x54eab
leaq 0x71883(%rip), %rdx     # 0xc671c
leaq 0x717b6(%rip), %rcx     # 0xc6656
xorl %edi, %edi
movq %r15, %rsi
movl $0x3bb, %r8d            # imm = 0x3BB
callq 0x66380
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zzlInsert
unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score) {
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;
    double s;

    ele = getDecodedObject(ele);
    while (eptr != NULL) {
        sptr = ziplistNext(zl,eptr);
        serverAssertWithInfo(NULL,ele,sptr != NULL);
        s = zzlGetScore(sptr);

        if (s > score) {
            /* First element with score larger than score for element to be
             * inserted. This means we should take its spot in the list to
             * maintain ordering. */
            zl = zzlInsertAt(zl,eptr,ele,score);
            break;
        } else if (s == score) {
            /* Ensure lexicographical ordering for elements. */
            if (zzlCompareElements(eptr,ele->ptr,sdslen(ele->ptr)) > 0) {
                zl = zzlInsertAt(zl,eptr,ele,score);
                break;
            }
        }

        /* Move to next element. */
        eptr = ziplistNext(zl,sptr);
    }

    /* Push on tail of list when it was not yet inserted. */
    if (eptr == NULL)
        zl = zzlInsertAt(zl,NULL,ele,score);

    decrRefCount(ele);
    return zl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x3ea40
movq %rax, %r15
movq %rbx, %rdi
callq 0x444b2
movq %rax, %rbx
testq %r15, %r15
sete %bpl
je 0x54f9c
leaq 0x7168f(%rip), %r13     # 0xc6588
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ead6
testq %rax, %rax
je 0x54fd1
movq %rax, %r12
movq %rax, %rdi
callq 0x54417
ucomisd (%rsp), %xmm0
ja 0x54f86
jne 0x54f69
jp 0x54f69
movq 0x8(%rbx), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x54f5b
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x54f5d
movq -0x11(%rsi), %rdx
jmp 0x54f5d
movzwl -0x5(%rsi), %edx
jmp 0x54f5d
movl -0x9(%rsi), %edx
jmp 0x54f5d
movzbl -0x3(%rsi), %edx
jmp 0x54f5d
xorl %edx, %edx
movq %r15, %rdi
callq 0x54532
testl %eax, %eax
jg 0x54f86
movq %r14, %rdi
movq %r12, %rsi
callq 0x3ead6
movq %rax, %r15
testq %rax, %rax
sete %bpl
jne 0x54ef9
jmp 0x54f9c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movsd (%rsp), %xmm0
callq 0x54d54
movq %rax, %r14
testb $0x1, %bpl
je 0x54fb7
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movsd (%rsp), %xmm0
callq 0x54d54
movq %rax, %r14
movq %rbx, %rdi
callq 0x440f3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71a2e(%rip), %rdx     # 0xc6a06
leaq 0x71677(%rip), %rcx     # 0xc6656
xorl %edi, %edi
movq %rbx, %rsi
movl $0x3d7, %r8d            # imm = 0x3D7
callq 0x66380
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zsetLength
unsigned int zsetLength(robj *zobj) {
    int length = -1;
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        length = zzlLength(zobj->ptr);
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        length = ((zset*)zobj->ptr)->zsl->length;
    } else {
        serverPanic("Unknown sorted set encoding");
    }
    return length;
}

// Assembly:
pushq %rax
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x7, %eax
je 0x551c5
cmpl $0x5, %eax
jne 0x551d2
movq 0x8(%rdi), %rdi
callq 0x3ef20
shrl %eax
jmp 0x551d0
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
popq %rcx
retq
leaq 0x6ea9d(%rip), %rdi     # 0xc3c76
leaq 0x71476(%rip), %rsi     # 0xc6656
movl $0x440, %edx            # imm = 0x440
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zsetConvertToZiplistIfNeeded
void zsetConvertToZiplistIfNeeded(robj *zobj, size_t maxelelen) {
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) return;
    zset *zset = zobj->ptr;

    if (zset->zsl->length <= server.zset_max_ziplist_entries &&
        maxelelen <= server.zset_max_ziplist_value)
            zsetConvert(zobj,OBJ_ENCODING_ZIPLIST);
}

// Assembly:
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
jne 0x554e8
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
leaq 0xb135d(%rip), %rax     # 0x106858
cmpq 0x948(%rax), %rcx
ja 0x554e7
cmpq %rsi, 0x950(%rax)
jb 0x554e7
movl $0x5, %esi
jmp 0x551f4
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zsetScore
int zsetScore(robj *zobj, robj *member, double *score) {
    if (!zobj || !member) return C_ERR;

    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        if (zzlFind(zobj->ptr, member, score) == NULL) return C_ERR;
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        zset *zs = zobj->ptr;
        dictEntry *de = dictFind(zs->dict, member);
        if (de == NULL) return C_ERR;
        *score = *(double*)dictGetVal(de);
    } else {
        serverPanic("Unknown sorted set encoding");
    }
    return C_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x55578
movq %rdx, %r14
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x7, %eax
je 0x55558
cmpl $0x5, %eax
jne 0x55582
movq 0x8(%rdi), %rdi
movq %r14, %rdx
callq 0x54c26
testq %rax, %rax
jne 0x55576
jmp 0x55578
movq 0x8(%rdi), %rax
movq (%rax), %rdi
callq 0x31cca
testq %rax, %rax
je 0x55578
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6e6ed(%rip), %rdi     # 0xc3c76
leaq 0x710c6(%rip), %rsi     # 0xc6656
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslParseRange
static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
    char *eptr;
    spec->minex = spec->maxex = 0;

    /* Parse the min-max interval. If one of the values is prefixed
     * by the "(" character, it's considered "open". For instance
     * ZRANGEBYSCORE zset (1.5 (2.5 will match min < x < max
     * ZRANGEBYSCORE zset 1.5 2.5 will instead match min <= x <= max */
    if (min->encoding == OBJ_ENCODING_INT) {
        spec->min = (long)min->ptr;
    } else {
        if (((char*)min->ptr)[0] == '(') {
            spec->min = strtod((char*)min->ptr+1,&eptr);
            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
            spec->minex = 1;
        } else {
            spec->min = strtod((char*)min->ptr,&eptr);
            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
        }
    }
    if (max->encoding == OBJ_ENCODING_INT) {
        spec->max = (long)max->ptr;
    } else {
        if (((char*)max->ptr)[0] == '(') {
            spec->max = strtod((char*)max->ptr+1,&eptr);
            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
            spec->maxex = 1;
        } else {
            spec->max = strtod((char*)max->ptr,&eptr);
            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
        }
    }

    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq $0x0, 0x10(%rdx)
movl $0xf0, %eax
andl (%rdi), %eax
movq 0x8(%rdi), %rdi
cmpl $0x10, %eax
jne 0x563a0
cvtsi2sd %rdi, %xmm0
movsd %xmm0, (%rbx)
movl $0xf0, %eax
andl (%r14), %eax
movq 0x8(%r14), %rdi
cmpl $0x10, %eax
jne 0x563d5
xorps %xmm0, %xmm0
cvtsi2sd %rdi, %xmm0
movsd %xmm0, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x28, (%rdi)
jne 0x5640b
incq %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x26cd0
movsd %xmm0, (%rbx)
movq (%r15), %rax
cmpb $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x56396
ucomisd %xmm0, %xmm0
jp 0x56396
movl $0x1, 0x10(%rbx)
jmp 0x56376
cmpb $0x28, (%rdi)
jne 0x5643c
incq %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x26cd0
movsd %xmm0, 0x8(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x56396
ucomisd %xmm0, %xmm0
jp 0x56396
movl $0x1, 0x14(%rbx)
jmp 0x56394
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x26cd0
movsd %xmm0, (%rbx)
movq (%r15), %rax
cmpb $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x56396
ucomisd %xmm0, %xmm0
jnp 0x56376
jmp 0x56396
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x26cd0
movsd %xmm0, 0x8(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x56396
ucomisd %xmm0, %xmm0
jnp 0x56394
jmp 0x56396
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zslParseLexRange
static int zslParseLexRange(robj *min, robj *max, zlexrangespec *spec) {
    /* The range can't be valid if objects are integer encoded.
     * Every item must start with ( or [. */
    if (min->encoding == OBJ_ENCODING_INT ||
        max->encoding == OBJ_ENCODING_INT) return C_ERR;

    spec->min = spec->max = NULL;
    if (zslParseLexRangeItem(min, &spec->min, &spec->minex) == C_ERR ||
        zslParseLexRangeItem(max, &spec->max, &spec->maxex) == C_ERR) {
        if (spec->min) decrRefCount(spec->min);
        if (spec->max) decrRefCount(spec->max);
        return C_ERR;
    } else {
        return C_OK;
    }
}

// Assembly:
movl $0xf0, %eax
movl (%rdi), %ecx
andl %eax, %ecx
cmpl $0x10, %ecx
jne 0x56482
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
andl (%rsi), %eax
cmpl $0x10, %eax
je 0x564e1
movq %rdx, %rbx
leaq 0x8(%rdx), %r14
addq $0x10, %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rsi
callq 0x54046
cmpl $-0x1, %eax
je 0x564c7
leaq 0x14(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x54046
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x564e6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x564d4
callq 0x440f3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x564e1
callq 0x440f3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiInitIterator
void zuiInitIterator(zsetopsrc *op) {
    if (op->subject == NULL)
        return;

    if (op->type == OBJ_SET) {
        iterset *it = &op->iter.set;
        if (op->encoding == OBJ_ENCODING_INTSET) {
            it->is.is = op->subject->ptr;
            it->is.ii = 0;
        } else if (op->encoding == OBJ_ENCODING_HT) {
            it->ht.dict = op->subject->ptr;
            it->ht.di = dictGetIterator(op->subject->ptr);
            it->ht.de = dictNext(it->ht.di);
        } else {
            serverPanic("Unknown set encoding");
        }
    } else if (op->type == OBJ_ZSET) {
        iterzset *it = &op->iter.zset;
        if (op->encoding == OBJ_ENCODING_ZIPLIST) {
            it->zl.zl = op->subject->ptr;
            it->zl.eptr = ziplistIndex(it->zl.zl,0);
            if (it->zl.eptr != NULL) {
                it->zl.sptr = ziplistNext(it->zl.zl,it->zl.eptr);
                serverAssert(it->zl.sptr != NULL);
            }
        } else if (op->encoding == OBJ_ENCODING_SKIPLIST) {
            it->sl.zs = op->subject->ptr;
            it->sl.node = it->sl.zs->zsl->header->level[0].forward;
        } else {
            serverPanic("Unknown sorted set encoding");
        }
    } else {
        serverPanic("Unsupported type");
    }
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x565e3
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
cmpl $0x3, %ecx
je 0x56551
cmpl $0x2, %ecx
jne 0x565e5
movl 0xc(%rbx), %ecx
cmpl $0x2, %ecx
je 0x565c2
cmpl $0x6, %ecx
jne 0x5660f
movq 0x8(%rax), %rax
movq %rax, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
jmp 0x565e3
movl 0xc(%rbx), %ecx
cmpl $0x7, %ecx
je 0x565a9
cmpl $0x5, %ecx
jne 0x565fa
movq 0x8(%rax), %rdi
movq %rdi, 0x18(%rbx)
xorl %esi, %esi
callq 0x3ea40
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x565e3
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x3ead6
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x565e3
leaq 0x7035b(%rip), %rdi     # 0xc68f1
leaq 0x700b9(%rip), %rsi     # 0xc6656
movl $0x685, %edx            # imm = 0x685
callq 0x654e1
jmp 0x56627
movq 0x8(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rbx)
jmp 0x565e3
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq 0x8(%rax), %rdi
callq 0x320bb
movq %rax, 0x20(%rbx)
movq %rax, %rdi
callq 0x32116
movq %rax, 0x28(%rbx)
popq %rbx
retq
leaq 0x70319(%rip), %rdi     # 0xc6905
leaq 0x70063(%rip), %rsi     # 0xc6656
movl $0x68e, %edx            # imm = 0x68E
jmp 0x56622
leaq 0x6d675(%rip), %rdi     # 0xc3c76
leaq 0x7004e(%rip), %rsi     # 0xc6656
movl $0x68b, %edx            # imm = 0x68B
jmp 0x56622
leaq 0x6f3d4(%rip), %rdi     # 0xc59ea
leaq 0x70039(%rip), %rsi     # 0xc6656
movl $0x67c, %edx            # imm = 0x67C
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiClearIterator
void zuiClearIterator(zsetopsrc *op) {
    if (op->subject == NULL)
        return;

    if (op->type == OBJ_SET) {
        iterset *it = &op->iter.set;
        if (op->encoding == OBJ_ENCODING_INTSET) {
            UNUSED(it); /* skip */
        } else if (op->encoding == OBJ_ENCODING_HT) {
            dictReleaseIterator(it->ht.di);
        } else {
            serverPanic("Unknown set encoding");
        }
    } else if (op->type == OBJ_ZSET) {
        iterzset *it = &op->iter.zset;
        if (op->encoding == OBJ_ENCODING_ZIPLIST) {
            UNUSED(it); /* skip */
        } else if (op->encoding == OBJ_ENCODING_SKIPLIST) {
            UNUSED(it); /* skip */
        } else {
            serverPanic("Unknown sorted set encoding");
        }
    } else {
        serverPanic("Unsupported type");
    }
}

// Assembly:
pushq %rax
cmpq $0x0, (%rdi)
je 0x56667
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x5665c
cmpl $0x2, %eax
jne 0x56669
movl 0xc(%rdi), %eax
cmpl $0x6, %eax
je 0x56667
cmpl $0x2, %eax
jne 0x5667e
movq 0x20(%rdi), %rdi
popq %rax
jmp 0x321d3
movl 0xc(%rdi), %eax
orl $0x2, %eax
cmpl $0x7, %eax
jne 0x56693
popq %rax
retq
leaq 0x70295(%rip), %rdi     # 0xc6905
leaq 0x6ffdf(%rip), %rsi     # 0xc6656
movl $0x6a9, %edx            # imm = 0x6A9
jmp 0x566a6
leaq 0x6f365(%rip), %rdi     # 0xc59ea
leaq 0x6ffca(%rip), %rsi     # 0xc6656
movl $0x69d, %edx            # imm = 0x69D
jmp 0x566a6
leaq 0x6d5dc(%rip), %rdi     # 0xc3c76
leaq 0x6ffb5(%rip), %rsi     # 0xc6656
movl $0x6a6, %edx            # imm = 0x6A6
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiLength
int zuiLength(zsetopsrc *op) {
    if (op->subject == NULL)
        return 0;

    if (op->type == OBJ_SET) {
        if (op->encoding == OBJ_ENCODING_INTSET) {
            return intsetLen(op->subject->ptr);
        } else if (op->encoding == OBJ_ENCODING_HT) {
            dict *ht = op->subject->ptr;
            return dictSize(ht);
        } else {
            serverPanic("Unknown set encoding");
        }
    } else if (op->type == OBJ_ZSET) {
        if (op->encoding == OBJ_ENCODING_ZIPLIST) {
            return zzlLength(op->subject->ptr);
        } else if (op->encoding == OBJ_ENCODING_SKIPLIST) {
            zset *zs = op->subject->ptr;
            return zs->zsl->length;
        } else {
            serverPanic("Unknown sorted set encoding");
        }
    } else {
        serverPanic("Unsupported type");
    }
}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x566e2
movl 0x8(%rdi), %ecx
cmpl $0x3, %ecx
je 0x566e6
cmpl $0x2, %ecx
jne 0x56719
movl 0xc(%rdi), %ecx
cmpl $0x2, %ecx
je 0x5670d
cmpl $0x6, %ecx
jne 0x56743
movq 0x8(%rax), %rdi
popq %rax
jmp 0x68a6e
xorl %eax, %eax
jmp 0x56717
movl 0xc(%rdi), %ecx
cmpl $0x7, %ecx
je 0x56700
cmpl $0x5, %ecx
jne 0x5672e
movq 0x8(%rax), %rdi
callq 0x3ef20
shrl %eax
jmp 0x56717
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
jmp 0x56717
movq 0x8(%rax), %rcx
movl 0x48(%rcx), %eax
addl 0x28(%rcx), %eax
popq %rcx
retq
leaq 0x701e5(%rip), %rdi     # 0xc6905
leaq 0x6ff2f(%rip), %rsi     # 0xc6656
movl $0x6c4, %edx            # imm = 0x6C4
jmp 0x56756
leaq 0x6d541(%rip), %rdi     # 0xc3c76
leaq 0x6ff1a(%rip), %rsi     # 0xc6656
movl $0x6c1, %edx            # imm = 0x6C1
jmp 0x56756
leaq 0x6f2a0(%rip), %rdi     # 0xc59ea
leaq 0x6ff05(%rip), %rsi     # 0xc6656
movl $0x6b8, %edx            # imm = 0x6B8
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiLongLongFromValue
int zuiLongLongFromValue(zsetopval *val) {
    if (!(val->flags & OPVAL_DIRTY_LL)) {
        val->flags |= OPVAL_DIRTY_LL;

        if (val->ele != NULL) {
            if (val->ele->encoding == OBJ_ENCODING_INT) {
                val->ell = (long)val->ele->ptr;
                val->flags |= OPVAL_VALID_LL;
            } else if (sdsEncodedObject(val->ele)) {
                if (string2ll(val->ele->ptr,sdslen(val->ele->ptr),&val->ell))
                    val->flags |= OPVAL_VALID_LL;
            } else {
                serverPanic("Unsupported element encoding");
            }
        } else if (val->estr != NULL) {
            if (string2ll((char*)val->estr,val->elen,&val->ell))
                val->flags |= OPVAL_VALID_LL;
        } else {
            /* The long long was already set, flag as valid. */
            val->flags |= OPVAL_VALID_LL;
        }
    }
    return val->flags & OPVAL_VALID_LL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
testb $0x2, %al
jne 0x569e9
movl %eax, %ecx
orl $0x2, %ecx
movl %ecx, (%rbx)
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x569a9
movl (%rcx), %edx
shrl $0x4, %edx
andl $0xf, %edx
je 0x56982
cmpl $0x8, %edx
je 0x56982
cmpl $0x1, %edx
jne 0x569f0
movq 0x8(%rcx), %rcx
movq %rcx, 0x40(%rbx)
jmp 0x569b7
movq 0x8(%rcx), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x569d3
leaq 0x6fc15(%rip), %rcx     # 0xc65b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x569d5
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x569b7
movl 0x38(%rbx), %esi
jmp 0x569d5
orl $0x6, %eax
jmp 0x569e7
movq -0x11(%rdi), %rsi
jmp 0x569d5
movzwl -0x5(%rdi), %esi
jmp 0x569d5
movl -0x9(%rdi), %esi
jmp 0x569d5
movzbl -0x3(%rdi), %esi
jmp 0x569d5
xorl %esi, %esi
leaq 0x40(%rbx), %rdx
callq 0x434c7
testl %eax, %eax
je 0x569e9
movl (%rbx), %eax
orl $0x4, %eax
movl %eax, (%rbx)
movl (%rbx), %eax
andl $0x4, %eax
popq %rbx
retq
leaq 0x6ff59(%rip), %rdi     # 0xc6950
leaq 0x6fc58(%rip), %rsi     # 0xc6656
movl $0x713, %edx            # imm = 0x713
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiObjectFromValue
robj *zuiObjectFromValue(zsetopval *val) {
    if (val->ele == NULL) {
        if (val->estr != NULL) {
            val->ele = createStringObject((char*)val->estr,val->elen);
        } else {
            val->ele = createStringObjectFromLongLong(val->ell);
        }
        val->flags |= OPVAL_DIRTY_ROBJ;
    }
    return val->ele;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x56a40
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x56a30
movl 0x38(%rbx), %esi
callq 0x43ba8
jmp 0x56a39
movq 0x40(%rbx), %rdi
callq 0x43bb7
movq %rax, 0x28(%rbx)
orb $0x1, (%rbx)
movq 0x28(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zuiBufferFromValue
int zuiBufferFromValue(zsetopval *val) {
    if (val->estr == NULL) {
        if (val->ele != NULL) {
            if (val->ele->encoding == OBJ_ENCODING_INT) {
                val->elen = ll2string((char*)val->_buf,sizeof(val->_buf),(long)val->ele->ptr);
                val->estr = val->_buf;
            } else if (sdsEncodedObject(val->ele)) {
                val->elen = sdslen(val->ele->ptr);
                val->estr = val->ele->ptr;
            } else {
                serverPanic("Unsupported element encoding");
            }
        } else {
            val->elen = ll2string((char*)val->_buf,sizeof(val->_buf),val->ell);
            val->estr = val->_buf;
        }
    }
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
jne 0x56abf
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x56aa3
movl (%rax), %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
je 0x56a7b
cmpl $0x8, %ecx
je 0x56a7b
cmpl $0x1, %ecx
jne 0x56aea
leaq 0x4(%rbx), %r14
movq 0x8(%rax), %rdx
jmp 0x56aab
movq 0x8(%rax), %r14
movzbl -0x1(%r14), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x56ae6
leaq 0x6fb2f(%rip), %rdx     # 0xc65c4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x56ab8
leaq 0x4(%rbx), %r14
movq 0x40(%rbx), %rdx
movl $0x20, %esi
movq %r14, %rdi
callq 0x433e5
movl %eax, 0x38(%rbx)
movq %r14, 0x30(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq -0x11(%r14), %rax
jmp 0x56ab8
movzwl -0x5(%r14), %eax
jmp 0x56ab8
movl -0x9(%r14), %eax
jmp 0x56ab8
movzbl -0x3(%r14), %eax
jmp 0x56ab8
xorl %eax, %eax
jmp 0x56ab8
leaq 0x6fe5f(%rip), %rdi     # 0xc6950
leaq 0x6fb5e(%rip), %rsi     # 0xc6656
movl $0x736, %edx            # imm = 0x736
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zcardCommand
void zcardCommand(client *c) {
    robj *key = c->argv[1];
    robj *zobj;

    if ((zobj = lookupKeyReadOrReply(c,key,shared.czero)) == NULL ||
        checkType(c,zobj,OBJ_ZSET)) return;

    addReplyLongLong(c,zsetLength(zobj));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xae938(%rip), %rax     # 0x1072b0
movq 0x20(%rax), %rdx
callq 0x44f89
testq %rax, %rax
je 0x5899d
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x441ab
testl %eax, %eax
je 0x589a5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x551a5
movl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40606
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zscoreCommand
void zscoreCommand(client *c) {
    robj *key = c->argv[1];
    robj *zobj;
    double score;

    if ((zobj = lookupKeyReadOrReply(c,key,shared.nullbulk)) == NULL ||
        checkType(c,zobj,OBJ_ZSET)) return;

    if (zsetScore(zobj,c->argv[2],&score) == C_ERR) {
        addReply(c,shared.nullbulk);
    } else {
        addReplyDouble(c,score);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xae8d7(%rip), %r15     # 0x1072b0
movq 0x50(%r15), %rdx
callq 0x44f89
testq %rax, %rax
je 0x58a34
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x441ab
testl %eax, %eax
jne 0x58a34
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x55517
cmpl $-0x1, %eax
je 0x58a28
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x40403
jmp 0x58a34
movq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x3fc19
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_zset.c
// Function: zscanCommand
void zscanCommand(client *c) {
    robj *o;
    unsigned long cursor;

    if (parseScanCursorOrReply(c,c->argv[2],&cursor) == C_ERR) return;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptyscan)) == NULL ||
        checkType(c,o,OBJ_ZSET)) return;
    scanGenericCommand(c,o,cursor);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0x45b7d
cmpl $-0x1, %eax
je 0x58d5f
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0xae58b(%rip), %rax     # 0x1072b0
movq 0x148(%rax), %rdx
movq %rbx, %rdi
callq 0x44f89
testq %rax, %rax
je 0x58d5f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x441ab
testl %eax, %eax
jne 0x58d5f
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45bfa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_hash.c
// Function: hashTypeTryConversion
void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
    int i;

    if (o->encoding != OBJ_ENCODING_ZIPLIST) return;

    for (i = start; i <= end; i++) {
        if (sdsEncodedObject(argv[i]) &&
            sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
        {
            hashTypeConvert(o, OBJ_ENCODING_HT);
            break;
        }
    }
}

// Assembly:
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
setne %al
cmpl %ecx, %edx
setg %r8b
orb %al, %r8b
jne 0x58e06
leaq 0xadacd(%rip), %rax     # 0x106858
movq 0x938(%rax), %rax
movslq %edx, %r8
leaq (%rsi,%r8,8), %rsi
subl %edx, %ecx
incl %ecx
xorl %edx, %edx
leaq 0x6dcaa(%rip), %r8      # 0xc6a50
movq (%rsi,%rdx,8), %r9
movl (%r9), %r10d
shrl $0x4, %r10d
testb $0x7, %r10b
jne 0x58dff
movq 0x8(%r9), %r10
movzbl -0x1(%r10), %r9d
movl %r9d, %r11d
andl $0x7, %r11d
cmpl $0x4, %r11d
ja 0x58df7
movslq (%r8,%r11,4), %r11
addq %r8, %r11
jmpq *%r11
shrl $0x3, %r9d
jmp 0x58dfa
movq -0x11(%r10), %r9
jmp 0x58dfa
movzwl -0x5(%r10), %r9d
jmp 0x58dfa
movl -0x9(%r10), %r9d
jmp 0x58dfa
movzbl -0x3(%r10), %r9d
jmp 0x58dfa
xorl %r9d, %r9d
cmpq %rax, %r9
ja 0x58e07
incq %rdx
cmpl %edx, %ecx
jne 0x58da6
retq
movl $0x2, %esi
jmp 0x58e11
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_hash.c
// Function: hashTypeConvert
void hashTypeConvert(robj *o, int enc) {
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        hashTypeConvertZiplist(o, enc);
    } else if (o->encoding == OBJ_ENCODING_HT) {
        serverPanic("Not implemented");
    } else {
        serverPanic("Unknown hash encoding");
    }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x58e25
popq %rax
jmp 0x5996e
cmpl $0x2, %eax
jne 0x58e3f
leaq 0x6dd88(%rip), %rdi     # 0xc6bb9
leaq 0x6dcc8(%rip), %rsi     # 0xc6b00
movl $0x1dc, %edx            # imm = 0x1DC
jmp 0x58e52
leaq 0x6cbbb(%rip), %rdi     # 0xc5a01
leaq 0x6dcb3(%rip), %rsi     # 0xc6b00
movl $0x1de, %edx            # imm = 0x1DE
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_hash.c
// Function: hashTypeGetFromZiplist
int hashTypeGetFromZiplist(robj *o, robj *field,
                           unsigned char **vstr,
                           unsigned int *vlen,
                           long long *vll)
{
    unsigned char *zl, *fptr = NULL, *vptr = NULL;
    int ret;

    serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);

    field = getDecodedObject(field);

    zl = o->ptr;
    fptr = ziplistIndex(zl, ZIPLIST_HEAD);
    if (fptr != NULL) {
        fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
        if (fptr != NULL) {
            /* Grab pointer to the value (fptr points to the field) */
            vptr = ziplistNext(zl, fptr);
            serverAssert(vptr != NULL);
        }
    }

    decrRefCount(field);

    if (vptr != NULL) {
        ret = ziplistGet(vptr, vstr, vlen, vll);
        serverAssert(ret);
        return 0;
    }

    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
jne 0x58fb2
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movq %rsi, %rdi
callq 0x444b2
movq %rax, %r12
movq 0x8(%r13), %r13
xorl %ebp, %ebp
movq %r13, %rdi
xorl %esi, %esi
callq 0x3ea40
testq %rax, %rax
je 0x58f63
movq 0x8(%r12), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x58f25
leaq 0x6db64(%rip), %rdi     # 0xc6a64
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
shrl $0x3, %edx
jmp 0x58f27
movq -0x11(%rsi), %rdx
jmp 0x58f27
movzwl -0x5(%rsi), %edx
jmp 0x58f27
movl -0x9(%rsi), %edx
jmp 0x58f27
movzbl -0x3(%rsi), %edx
jmp 0x58f27
xorl %edx, %edx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x3ece4
testq %rax, %rax
je 0x58f61
movq %r13, %rdi
movq %rax, %rsi
callq 0x3ead6
movq %rax, %rbp
testq %rax, %rax
jne 0x58f63
leaq 0x6dbb6(%rip), %rdi     # 0xc6b09
leaq 0x6dba6(%rip), %rsi     # 0xc6b00
movl $0x54, %edx
jmp 0x58fc5
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x440f3
testq %rbp, %rbp
je 0x58f9e
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3eb60
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x58fa3
leaq 0x6db86(%rip), %rdi     # 0xc6b16
leaq 0x6db69(%rip), %rsi     # 0xc6b00
movl $0x5c, %edx
jmp 0x58fc5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6db23(%rip), %rdi     # 0xc6adc
leaq 0x6db40(%rip), %rsi     # 0xc6b00
movl $0x49, %edx
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_hash.c
// Function: hashTypeGetFromHashTable
int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) {
    dictEntry *de;

    serverAssert(o->encoding == OBJ_ENCODING_HT);

    de = dictFind(o->ptr, field);
    if (de == NULL) return -1;
    *value = dictGetVal(de);
    return 0;
}

// Assembly:
pushq %rbx
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x20, %eax
jne 0x59004
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x31cca
testq %rax, %rax
je 0x58ffd
movq 0x8(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x59002
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
leaq 0x6db0f(%rip), %rdi     # 0xc6b1a
leaq 0x6daee(%rip), %rsi     # 0xc6b00
movl $0x68, %edx
callq 0x654e1
movl $0x1, %edi
callq 0x263d0