LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x60b1e
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x60b20
jmp 0x60b4b
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xdd1b9(%rip), %rdx     # 0x13dce8
leaq 0xdd0ec(%rip), %rcx     # 0x13dc22
movl $0x3bb, %r8d            # imm = 0x3BB
callq 0x78360
movl $0x1, %edi
callq 0x263c0
leaq -0xb0(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movl $0x80, %esi
callq 0x47c60
movl %eax, -0xb4(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x60bd7
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0x410b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl -0xb4(%rbp), %edx
movl $0x1, %ecx
callq 0x410b0
movq %rax, -0x8(%rbp)
jmp 0x60cac
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movl %eax, %ecx
callq 0x41530
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq -0xc0(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x60c63
jmp 0x60c8e
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xdd08c(%rip), %rdx     # 0x13dcfe
leaq 0xdcfa9(%rip), %rcx     # 0x13dc22
movl $0x3c7, %r8d            # imm = 0x3C7
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movl -0xb4(%rbp), %ecx
callq 0x41530
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x494f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60df0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60d16
jmp 0x60d41
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xdd2ad(%rip), %rdx     # 0x13dfd2
leaq 0xdcef6(%rip), %rcx     # 0x13dc22
movl $0x3d7, %r8d            # imm = 0x3D7
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x28(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x60d77
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x60ae0
movq %rax, -0x8(%rbp)
jmp 0x60df0
movsd -0x30(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x60dd8
jp 0x60dd8
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0x5fff0
cmpl $0x0, %eax
jle 0x60dd6
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x60ae0
movq %rax, -0x8(%rbp)
jmp 0x60df0
jmp 0x60dd8
jmp 0x60dda
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x20(%rbp)
jmp 0x60cf1
cmpq $0x0, -0x20(%rbp)
jne 0x60e11
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x60ae0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48f70
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlDeleteRangeByScore
unsigned char *zzlDeleteRangeByScore(unsigned char *zl, zrangespec *range, unsigned long *deleted) {
    unsigned char *eptr, *sptr;
    double score;
    unsigned long num = 0;

    if (deleted != NULL) *deleted = 0;

    eptr = zzlFirstInRange(zl,range);
    if (eptr == NULL) return zl;

    /* When the tail of the ziplist is deleted, eptr will point to the sentinel
     * byte and ziplistNext will return NULL. */
    while ((sptr = ziplistNext(zl,eptr)) != NULL) {
        score = zzlGetScore(sptr);
        if (zslValueLteMax(score,range)) {
            /* Delete both the element and the score. */
            zl = ziplistDelete(zl,&eptr);
            zl = ziplistDelete(zl,&eptr);
            num++;
        } else {
            /* No longer in range. */
            break;
        }
    }

    if (deleted != NULL) *deleted = num;
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60e5e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x603a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x60e83
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60f0b
jmp 0x60e85
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x60ef1
movq -0x30(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
je 0x60eed
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x60eef
jmp 0x60ef1
jmp 0x60e85
cmpq $0x0, -0x20(%rbp)
je 0x60f03
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlDeleteRangeByLex
unsigned char *zzlDeleteRangeByLex(unsigned char *zl, zlexrangespec *range, unsigned long *deleted) {
    unsigned char *eptr, *sptr;
    unsigned long num = 0;

    if (deleted != NULL) *deleted = 0;

    eptr = zzlFirstInLexRange(zl,range);
    if (eptr == NULL) return zl;

    /* When the tail of the ziplist is deleted, eptr will point to the sentinel
     * byte and ziplistNext will return NULL. */
    while ((sptr = ziplistNext(zl,eptr)) != NULL) {
        if (zzlLexValueLteMax(eptr,range)) {
            /* Delete both the element and the score. */
            zl = ziplistDelete(zl,&eptr);
            zl = ziplistDelete(zl,&eptr);
            num++;
        } else {
            /* No longer in range. */
            break;
        }
    }

    if (deleted != NULL) *deleted = num;
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60f4e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60780
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x60f70
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60fe9
jmp 0x60f72
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x60fcf
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60740
cmpl $0x0, %eax
je 0x60fcb
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x60fcd
jmp 0x60fcf
jmp 0x60f72
cmpq $0x0, -0x20(%rbp)
je 0x60fe1
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlDeleteRangeByRank
unsigned char *zzlDeleteRangeByRank(unsigned char *zl, unsigned int start, unsigned int end, unsigned long *deleted) {
    unsigned int num = (end-start)+1;
    if (deleted) *deleted = num;
    zl = ziplistDeleteRange(zl,2*(start-1),2*num);
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61035
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
shll %esi
movl -0x1c(%rbp), %edx
shll %edx
callq 0x415d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x61096
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x600c0
movl %eax, -0xc(%rbp)
jmp 0x610e0
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x7, %eax
jne 0x610bc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, -0xc(%rbp)
jmp 0x610de
leaq 0xda627(%rip), %rdi     # 0x13b6ea
leaq 0xdcb58(%rip), %rsi     # 0x13dc22
movl $0x440, %edx            # imm = 0x440
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x610e0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x614c3
jmp 0x6150d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x116cf6(%rip), %rcx    # 0x1781d8
cmpq 0x958(%rcx), %rax
ja 0x6150d
movq -0x10(%rbp), %rax
leaq 0x116ce2(%rip), %rcx    # 0x1781d8
cmpq 0x960(%rcx), %rax
ja 0x6150d
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x610f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x61542
cmpq $0x0, -0x18(%rbp)
jne 0x6154e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6160a
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x61588
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x60970
cmpq $0x0, %rax
jne 0x61586
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6160a
jmp 0x61603
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x7, %eax
jne 0x615df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2dcb0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x615c9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6160a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x61601
leaq 0xda104(%rip), %rdi     # 0x13b6ea
leaq 0xdc635(%rip), %rsi     # 0x13dc22
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x61603
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
je 0x62986
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x62992
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62a1f
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
callq 0x5f810
cmpl $-0x1, %eax
je 0x629e1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
addq $0x14, %rdx
callq 0x5f810
cmpl $-0x1, %eax
jne 0x62a18
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x629f7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x48f70
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x62a0f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x48f70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62a1f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x62cbb
jmp 0x62d94
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x62d1c
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x6, 0xc(%rax)
jne 0x62cdd
jmp 0x62d1a
movq -0x8(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x62cf6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e600
jmp 0x62d18
leaq 0xda500(%rip), %rdi     # 0x13d1fd
leaq 0xdaf1e(%rip), %rsi     # 0x13dc22
movl $0x69d, %edx            # imm = 0x69D
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x62d1a
jmp 0x62d94
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x62d70
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, 0xc(%rax)
jne 0x62d3e
jmp 0x62d6e
movq -0x8(%rbp), %rax
cmpl $0x7, 0xc(%rax)
jne 0x62d4a
jmp 0x62d6c
leaq 0xd8999(%rip), %rdi     # 0x13b6ea
leaq 0xdaeca(%rip), %rsi     # 0x13dc22
movl $0x6a6, %edx            # imm = 0x6A6
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x62d6e
jmp 0x62d92
leaq 0xdb15a(%rip), %rdi     # 0x13ded1
leaq 0xdaea4(%rip), %rsi     # 0x13dc22
movl $0x6a9, %edx            # imm = 0x6A9
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x62d94
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x62dc2
movl $0x0, -0x4(%rbp)
jmp 0x62ed8
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x62e41
movq -0x10(%rbp), %rax
cmpl $0x6, 0xc(%rax)
jne 0x62dee
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x7ba20
movl %eax, -0x4(%rbp)
jmp 0x62ed8
movq -0x10(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x62e1f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x48(%rcx), %rax
movl %eax, -0x4(%rbp)
jmp 0x62ed8
leaq 0xda3d7(%rip), %rdi     # 0x13d1fd
leaq 0xdadf5(%rip), %rsi     # 0x13dc22
movl $0x6b8, %edx            # imm = 0x6B8
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x62eb6
movq -0x10(%rbp), %rax
cmpl $0x5, 0xc(%rax)
jne 0x62e6a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x600c0
movl %eax, -0x4(%rbp)
jmp 0x62ed8
movq -0x10(%rbp), %rax
cmpl $0x7, 0xc(%rax)
jne 0x62e94
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x62ed8
leaq 0xd884f(%rip), %rdi     # 0x13b6ea
leaq 0xdad80(%rip), %rsi     # 0x13dc22
movl $0x6c1, %edx            # imm = 0x6C1
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
leaq 0xdb014(%rip), %rdi     # 0x13ded1
leaq 0xdad5e(%rip), %rsi     # 0x13dc22
movl $0x6c4, %edx            # imm = 0x6C4
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x63322
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x632d8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x63241
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x632d6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x6326b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x632b2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rdx
addq $0x40, %rdx
callq 0x47970
cmpl $0x0, %eax
je 0x632b0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x632d4
leaq 0xdac63(%rip), %rdi     # 0x13df1c
leaq 0xda962(%rip), %rsi     # 0x13dc22
movl $0x713, %edx            # imm = 0x713
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x632d6
jmp 0x63320
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x63313
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, %esi
movq -0x8(%rbp), %rdx
addq $0x40, %rdx
callq 0x47970
cmpl $0x0, %eax
je 0x63311
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x6331e
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x63320
jmp 0x63322
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x633a8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x63385
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x6339d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x486f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x634ed
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x634b8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x63438
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdx
movl $0x20, %esi
callq 0x477e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x634b6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x63462
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x63492
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x634b4
leaq 0xdaa83(%rip), %rdi     # 0x13df1c
leaq 0xda782(%rip), %rsi     # 0x13dc22
movl $0x736, %edx            # imm = 0x736
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x634b6
jmp 0x634eb
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
movl $0x20, %esi
callq 0x477e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x634ed
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zunionInterAggregate
inline static void zunionInterAggregate(double *target, double val, int aggregate) {
    if (aggregate == REDIS_AGGR_SUM) {
        *target = *target + val;
        /* The result of adding two doubles is NaN when one variable
         * is +inf and the other is -inf. When these numbers are added,
         * we maintain the convention of the result being 0.0. */
        if (isnan(*target)) *target = 0.0;
    } else if (aggregate == REDIS_AGGR_MIN) {
        *target = val < *target ? val : *target;
    } else if (aggregate == REDIS_AGGR_MAX) {
        *target = val > *target ? val : *target;
    } else {
        /* safety net */
        serverPanic("Unknown ZUNION/INTER aggregate type");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x64354
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x64344
jmp 0x6434f
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x643f8
cmpl $0x2, -0x14(%rbp)
jne 0x64395
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x64379
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x64386
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x643f6
cmpl $0x3, -0x14(%rbp)
jne 0x643d2
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x643b6
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x643c3
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x643f4
leaq 0xd9c42(%rip), %rdi     # 0x13e01b
leaq 0xd9842(%rip), %rsi     # 0x13dc22
movl $0x78d, %edx            # imm = 0x78D
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x643f6
jmp 0x643f8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x112ef5(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x65d75
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x65d77
jmp 0x65d95
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x61060
movq -0x20(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x112e75(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x65df5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x65df7
jmp 0x65e39
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x61520
cmpl $-0x1, %eax
jne 0x65e2b
movq -0x8(%rbp), %rdi
leaq 0x112e20(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x65e39
movq -0x8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x43480
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4b690
cmpl $-0x1, %eax
jne 0x661fc
jmp 0x66253
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x112a2d(%rip), %rax    # 0x178c40
movq 0x148(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x66240
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x66242
jmp 0x66253
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4b740
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
je 0x6628c
jmp 0x6630e
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x6630e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x662cc
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x66301
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x66320
leaq 0x111ef0(%rip), %rcx    # 0x1781d8
cmpq 0x948(%rcx), %rax
jbe 0x66301
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x663b0
jmp 0x6630e
jmp 0x66303
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66292
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x663de
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x67360
jmp 0x66433
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66411
leaq 0xd7d3f(%rip), %rdi     # 0x13e135
leaq 0xd7c7f(%rip), %rsi     # 0x13e07c
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
leaq 0xd6dfc(%rip), %rdi     # 0x13d214
leaq 0xd7c5d(%rip), %rsi     # 0x13e07c
movl $0x1de, %edx            # imm = 0x1DE
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x664ef
jmp 0x66511
leaq 0xd7b62(%rip), %rdi     # 0x13e058
leaq 0xd7b7f(%rip), %rsi     # 0x13e07c
movl $0x49, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x18(%rbp), %rdi
callq 0x494f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x665c4
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x66320
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0x41710
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x665c2
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x412e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x6659e
jmp 0x665c0
leaq 0xd7ae0(%rip), %rdi     # 0x13e085
leaq 0xd7ad0(%rip), %rsi     # 0x13e07c
movl $0x54, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x665c2
jmp 0x665c4
movq -0x18(%rbp), %rdi
callq 0x48f70
cmpq $0x0, -0x48(%rbp)
je 0x6661f
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x41470
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x665f4
jmp 0x66616
leaq 0xd7a97(%rip), %rdi     # 0x13e092
leaq 0xd7a7a(%rip), %rsi     # 0x13e07c
movl $0x5c, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movl $0x0, -0x4(%rbp)
jmp 0x66626
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66657
jmp 0x66679
leaq 0xd7a38(%rip), %rdi     # 0x13e096
leaq 0xd7a17(%rip), %rsi     # 0x13e07c
movl $0x68, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2dcb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6669e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x666b4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetObject
robj *hashTypeGetObject(robj *o, robj *field) {
    robj *value = NULL;

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) {
            if (vstr) {
                value = createStringObject((char*)vstr, vlen);
            } else {
                value = createStringObjectFromLongLong(vll);
            }
        }
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0) {
            incrRefCount(aux);
            value = aux;
        }
    } else {
        serverPanic("Unknown hash encoding");
    }
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x66750
movq $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x664b0
cmpl $0x0, %eax
jne 0x6674e
cmpq $0x0, -0x20(%rbp)
je 0x6673f
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, -0x18(%rbp)
jmp 0x6674c
movq -0x30(%rbp), %rdi
callq 0x486f0
movq %rax, -0x18(%rbp)
jmp 0x6674e
jmp 0x667ae
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x6678a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x66630
cmpl $0x0, %eax
jne 0x66788
movq -0x38(%rbp), %rdi
callq 0x487b0
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x667ac
leaq 0xd6a83(%rip), %rdi     # 0x13d214
leaq 0xd78e4(%rip), %rsi     # 0x13e07c
movl $0x8d, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x667ae
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetValueLength
size_t hashTypeGetValueLength(robj *o, robj *field) {
    size_t len = 0;
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0)
            len = vstr ? vlen : sdigits10(vll);
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0)
            len = stringObjectLen(aux);
    } else {
        serverPanic("Unknown hash encoding");
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x6684a
movq $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x664b0
cmpl $0x0, %eax
jne 0x66848
cmpq $0x0, -0x20(%rbp)
je 0x66833
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x6683f
movq -0x30(%rbp), %rdi
callq 0x47770
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x668a4
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66880
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x66630
cmpl $0x0, %eax
jne 0x6687e
movq -0x38(%rbp), %rdi
callq 0x498c0
movq %rax, -0x18(%rbp)
jmp 0x668a2
leaq 0xd698d(%rip), %rdi     # 0x13d214
leaq 0xd77ee(%rip), %rsi     # 0x13e07c
movl $0xa4, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x668a4
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeExists
int hashTypeExists(robj *o, robj *field) {
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) return 1;
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0) return 1;
    } else {
        serverPanic("Unknown hash encoding");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x66917
movq $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x664b0
cmpl $0x0, %eax
jne 0x66915
movl $0x1, -0x4(%rbp)
jmp 0x66974
jmp 0x6696d
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66949
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x66630
cmpl $0x0, %eax
jne 0x66947
movl $0x1, -0x4(%rbp)
jmp 0x66974
jmp 0x6696b
leaq 0xd68c4(%rip), %rdi     # 0x13d214
leaq 0xd7725(%rip), %rsi     # 0x13e07c
movl $0xb7, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x6696d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeLength
unsigned long hashTypeLength(robj *o) {
    unsigned long length = ULONG_MAX;

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        length = ziplistLen(o->ptr) / 2;
    } else if (o->encoding == OBJ_ENCODING_HT) {
        length = dictSize((dict*)o->ptr);
    } else {
        serverPanic("Unknown hash encoding");
    }

    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x66c4c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x419c0
shrl %eax
movl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0x66c9f
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66c7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0x48(%rcx), %rax
movq %rax, -0x10(%rbp)
jmp 0x66c9d
leaq 0xd6592(%rip), %rdi     # 0x13d214
leaq 0xd73f3(%rip), %rsi     # 0x13e07c
movl $0x124, %edx            # imm = 0x124
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x66c9f
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)