LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslDeleteRangeByLex
unsigned long zslDeleteRangeByLex(zskiplist *zsl, zlexrangespec *range, dict *dict) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long removed = 0;
    int i;


    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward &&
            !zslLexValueGteMin(x->level[i].forward->obj,range))
                x = x->level[i].forward;
        update[i] = x;
    }

    /* Current node is the last with score < or <= min. */
    x = x->level[0].forward;

    /* Delete nodes while in range. */
    while (x && zslLexValueLteMax(x->obj,range)) {
        zskiplistNode *next = x->level[0].forward;
        zslDeleteNode(zsl,x,update);
        dictDelete(dict,x->obj);
        zslFreeNode(x);
        removed++;
        x = next;
    }
    return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x130(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x134(%rbp)
cmpl $0x0, -0x134(%rbp)
jl 0x5f1aa
jmp 0x5f0ef
movq -0x128(%rbp), %rcx
addq $0x18, %rcx
movslq -0x134(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x141(%rbp)
je 0x5f14c
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x134(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f280
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x141(%rbp)
movb -0x141(%rbp), %al
testb $0x1, %al
jne 0x5f158
jmp 0x5f180
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x134(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
jmp 0x5f0ef
movq -0x128(%rbp), %rcx
movslq -0x134(%rbp), %rax
movq %rcx, -0x120(%rbp,%rax,8)
movl -0x134(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x5f0e0
movq -0x128(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x128(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x128(%rbp)
movb %al, -0x142(%rbp)
je 0x5f1ed
movq -0x128(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f2f0
cmpl $0x0, %eax
setne %al
movb %al, -0x142(%rbp)
movb -0x142(%rbp), %al
testb $0x1, %al
jne 0x5f1f9
jmp 0x5f266
movq -0x128(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x8(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x5e670
movq -0x18(%rbp), %rdi
movq -0x128(%rbp), %rax
movq (%rax), %rsi
callq 0x2de50
movq -0x128(%rbp), %rdi
callq 0x5e070
movq -0x130(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x130(%rbp)
movq -0x140(%rbp), %rax
movq %rax, -0x128(%rbp)
jmp 0x5f1bc
movq -0x130(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslDeleteRangeByRank
unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long traversed = 0, removed = 0;
    int i;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) < start) {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }

    traversed++;
    x = x->level[0].forward;
    while (x && traversed <= end) {
        zskiplistNode *next = x->level[0].forward;
        zslDeleteNode(zsl,x,update);
        dictDelete(dict,x->obj);
        zslFreeNode(x);
        removed++;
        traversed++;
        x = next;
    }
    return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq $0x0, -0x130(%rbp)
movq $0x0, -0x138(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x13c(%rbp)
cmpl $0x0, -0x13c(%rbp)
jl 0x5f4a0
jmp 0x5f3bc
movq -0x128(%rbp), %rcx
addq $0x18, %rcx
movslq -0x13c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x149(%rbp)
je 0x5f418
movq -0x130(%rbp), %rax
movq -0x128(%rbp), %rcx
addq $0x18, %rcx
movslq -0x13c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x149(%rbp)
movb -0x149(%rbp), %al
testb $0x1, %al
jne 0x5f424
jmp 0x5f476
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x13c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addq -0x130(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x13c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
jmp 0x5f3bc
movq -0x128(%rbp), %rcx
movslq -0x13c(%rbp), %rax
movq %rcx, -0x120(%rbp,%rax,8)
movl -0x13c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x13c(%rbp)
jmp 0x5f3ad
movq -0x130(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x130(%rbp)
movq -0x128(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x128(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x128(%rbp)
movb %al, -0x14a(%rbp)
je 0x5f4ec
movq -0x130(%rbp), %rax
movl -0x10(%rbp), %ecx
cmpq %rcx, %rax
setbe %al
movb %al, -0x14a(%rbp)
movb -0x14a(%rbp), %al
testb $0x1, %al
jne 0x5f4f8
jmp 0x5f577
movq -0x128(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x148(%rbp)
movq -0x8(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x5e670
movq -0x18(%rbp), %rdi
movq -0x128(%rbp), %rax
movq (%rax), %rsi
callq 0x2de50
movq -0x128(%rbp), %rdi
callq 0x5e070
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
movq -0x130(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x130(%rbp)
movq -0x148(%rbp), %rax
movq %rax, -0x128(%rbp)
jmp 0x5f4c4
movq -0x138(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslGetRank
unsigned long zslGetRank(zskiplist *zsl, double score, robj *o) {
    zskiplistNode *x;
    unsigned long rank = 0;
    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,o) <= 0))) {
            rank += x->level[i].span;
            x = x->level[i].forward;
        }

        /* x might be equal to zsl->header, so test if obj is non-NULL */
        if (x->obj && equalStringObjects(x->obj,o)) {
            return rank;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x5f6fd
jmp 0x5f5d1
movq -0x28(%rbp), %rcx
addq $0x18, %rcx
movslq -0x34(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x35(%rbp)
je 0x5f67e
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x36(%rbp)
ja 0x5f678
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
xorl %eax, %eax
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x37(%rbp)
jne 0x5f672
jp 0x5f672
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x497e0
cmpl $0x0, %eax
setle %al
movb %al, -0x37(%rbp)
movb -0x37(%rbp), %al
movb %al, -0x36(%rbp)
movb -0x36(%rbp), %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x5f687
jmp 0x5f6c4
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5f5d1
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5f6ed
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x49840
cmpl $0x0, %eax
je 0x5f6ed
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5f705
jmp 0x5f6ef
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5f5c5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslGetElementByRank
zskiplistNode* zslGetElementByRank(zskiplist *zsl, unsigned long rank) {
    zskiplistNode *x;
    unsigned long traversed = 0;
    int i;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) <= rank)
        {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        if (traversed == rank) {
            return x;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x5f7f7
jmp 0x5f748
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x2d(%rbp)
je 0x5f78d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
setbe %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x5f796
jmp 0x5f7d3
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5f748
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5f7e7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5f7ff
jmp 0x5f7e9
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5f73c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x28, %eax
je 0x5f918
jmp 0x5f845
movl -0x2c(%rbp), %eax
subl $0x2b, %eax
je 0x5f86a
jmp 0x5f84f
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x5f8c1
jmp 0x5f859
movl -0x2c(%rbp), %eax
subl $0x5b, %eax
je 0x5f95a
jmp 0x5f99c
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x5f883
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f9a3
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
leaq 0x1193ac(%rip), %rax    # 0x178c40
movq 0x158(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq 0x119397(%rip), %rax    # 0x178c40
movq 0x158(%rax), %rdi
callq 0x487b0
movl $0x0, -0x4(%rbp)
jmp 0x5f9a3
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x5f8da
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f9a3
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
leaq 0x119355(%rip), %rax    # 0x178c40
movq 0x150(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq 0x119340(%rip), %rax    # 0x178c40
movq 0x150(%rax), %rdi
callq 0x487b0
movl $0x0, -0x4(%rbp)
jmp 0x5f9a3
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5f9b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x486a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5f9a3
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5f9b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x486a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5f9a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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_zset.c
// Function: compareStringObjectsForLexRange
int compareStringObjectsForLexRange(robj *a, robj *b) {
    if (a == b) return 0; /* This makes sure that we handle inf,inf and
                             -inf,-inf ASAP. One special case less. */
    if (a == shared.minstring || b == shared.maxstring) return -1;
    if (a == shared.maxstring || b == shared.minstring) return 1;
    return compareStringObjects(a,b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5fa93
movl $0x0, -0x4(%rbp)
jmp 0x5fb05
movq -0x10(%rbp), %rax
leaq 0x1191a2(%rip), %rcx    # 0x178c40
cmpq 0x150(%rcx), %rax
je 0x5fabb
movq -0x18(%rbp), %rax
leaq 0x11918e(%rip), %rcx    # 0x178c40
cmpq 0x158(%rcx), %rax
jne 0x5fac4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fb05
movq -0x10(%rbp), %rax
leaq 0x119171(%rip), %rcx    # 0x178c40
cmpq 0x158(%rcx), %rax
je 0x5faec
movq -0x18(%rbp), %rax
leaq 0x11915d(%rip), %rcx    # 0x178c40
cmpq 0x150(%rcx), %rax
jne 0x5faf5
movl $0x1, -0x4(%rbp)
jmp 0x5fb05
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x497e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslIsInLexRange
int zslIsInLexRange(zskiplist *zsl, zlexrangespec *range) {
    zskiplistNode *x;

    /* Test for ranges that will always be empty. */
    if (compareStringObjectsForLexRange(range->min,range->max) > 1 ||
            (compareStringObjects(range->min,range->max) == 0 &&
            (range->minex || range->maxex)))
        return 0;
    x = zsl->tail;
    if (x == NULL || !zslLexValueGteMin(x->obj,range))
        return 0;
    x = zsl->header->level[0].forward;
    if (x == NULL || !zslLexValueLteMax(x->obj,range))
        return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5fa70
cmpl $0x1, %eax
jg 0x5fb66
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x497e0
cmpl $0x0, %eax
jne 0x5fb6f
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x5fb66
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x5fb6f
movl $0x0, -0x4(%rbp)
jmp 0x5fbdb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5fb97
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f280
cmpl $0x0, %eax
jne 0x5fba0
movl $0x0, -0x4(%rbp)
jmp 0x5fbdb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5fbcb
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f2f0
cmpl $0x0, %eax
jne 0x5fbd4
movl $0x0, -0x4(%rbp)
jmp 0x5fbdb
movl $0x1, -0x4(%rbp)
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: zslFirstInLexRange
zskiplistNode *zslFirstInLexRange(zskiplist *zsl, zlexrangespec *range) {
    zskiplistNode *x;
    int i;

    /* If everything is out of range, return early. */
    if (!zslIsInLexRange(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 &&
            !zslLexValueGteMin(x->level[i].forward->obj,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 (!zslLexValueLteMax(x->obj,range)) return NULL;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5fb10
cmpl $0x0, %eax
jne 0x5fc1f
movq $0x0, -0x8(%rbp)
jmp 0x5fd21
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x5fcc3
jmp 0x5fc43
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x25(%rbp)
je 0x5fc8e
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f280
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x5fc97
jmp 0x5fcb3
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5fc43
jmp 0x5fcb5
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5fc37
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5fcd8
jmp 0x5fcfa
leaq 0xddf4c(%rip), %rdi     # 0x13dc2b
leaq 0xddf3c(%rip), %rsi     # 0x13dc22
movl $0x257, %edx            # imm = 0x257
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f2f0
cmpl $0x0, %eax
jne 0x5fd19
movq $0x0, -0x8(%rbp)
jmp 0x5fd21
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslLastInLexRange
zskiplistNode *zslLastInLexRange(zskiplist *zsl, zlexrangespec *range) {
    zskiplistNode *x;
    int i;

    /* If everything is out of range, return early. */
    if (!zslIsInLexRange(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 &&
            zslLexValueLteMax(x->level[i].forward->obj,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 (!zslLexValueGteMin(x->obj,range)) return NULL;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5fb10
cmpl $0x0, %eax
jne 0x5fd5f
movq $0x0, -0x8(%rbp)
jmp 0x5fe53
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x5fe01
jmp 0x5fd83
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x25(%rbp)
je 0x5fdcc
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f2f0
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x5fdd5
jmp 0x5fdf1
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5fd83
jmp 0x5fdf3
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5fd77
cmpq $0x0, -0x20(%rbp)
je 0x5fe0a
jmp 0x5fe2c
leaq 0xdde1a(%rip), %rdi     # 0x13dc2b
leaq 0xdde0a(%rip), %rsi     # 0x13dc22
movl $0x270, %edx            # imm = 0x270
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f280
cmpl $0x0, %eax
jne 0x5fe4b
movq $0x0, -0x8(%rbp)
jmp 0x5fe53
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5fe78
jmp 0x5fe9a
leaq 0xde153(%rip), %rdi     # 0x13dfd2
leaq 0xddd9c(%rip), %rsi     # 0x13dc22
movl $0x282, %edx            # imm = 0x282
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x41470
cmpl $0x0, %eax
je 0x5feb6
jmp 0x5fed8
leaq 0xddd78(%rip), %rdi     # 0x13dc35
leaq 0xddd5e(%rip), %rsi     # 0x13dc22
movl $0x283, %edx            # imm = 0x283
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
cmpq $0x0, -0x10(%rbp)
je 0x5ff19
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x26c60
movl -0x14(%rbp), %eax
movb $0x0, -0xa0(%rbp,%rax)
leaq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x26cd0
movsd %xmm0, -0xa8(%rbp)
jmp 0x5ff27
cvtsi2sdq -0x20(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0xa8(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ff55
jmp 0x5ff77
leaq 0xde076(%rip), %rdi     # 0x13dfd2
leaq 0xddcbf(%rip), %rsi     # 0x13dc22
movl $0x298, %edx            # imm = 0x298
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x41470
cmpl $0x0, %eax
je 0x5ff93
jmp 0x5ffb5
leaq 0xddc9b(%rip), %rdi     # 0x13dc35
leaq 0xddc81(%rip), %rsi     # 0x13dc22
movl $0x299, %edx            # imm = 0x299
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
cmpq $0x0, -0x18(%rbp)
je 0x5ffd0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, -0x8(%rbp)
jmp 0x5ffdd
movq -0x28(%rbp), %rdi
callq 0x486f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlCompareElements
int zzlCompareElements(unsigned char *eptr, unsigned char *cstr, unsigned int clen) {
    unsigned char *vstr;
    unsigned int vlen;
    long long vlong;
    unsigned char vbuf[32];
    int minlen, cmp;

    serverAssert(ziplistGet(eptr,&vstr,&vlen,&vlong));
    if (vstr == NULL) {
        /* Store string representation of long long in buf. */
        vlen = ll2string((char*)vbuf,sizeof(vbuf),vlong);
        vstr = vbuf;
    }

    minlen = (vlen < clen) ? vlen : clen;
    cmp = memcmp(vstr,cstr,minlen);
    if (cmp == 0) return vlen-clen;
    return cmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x41470
cmpl $0x0, %eax
je 0x6001f
jmp 0x60041
leaq 0xddc33(%rip), %rdi     # 0x13dc59
leaq 0xddbf5(%rip), %rsi     # 0x13dc22
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
cmpq $0x0, -0x28(%rbp)
jne 0x60065
leaq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x20, %esi
callq 0x477e0
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x60075
movl -0x2c(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x6007b
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x64(%rbp), %rdx
callq 0x269b0
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
jne 0x600a6
movl -0x2c(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x600ac
movl -0x68(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6010a
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6010a
jmp 0x6012c
leaq 0xddb6c(%rip), %rdi     # 0x13dc7d
leaq 0xddb0a(%rip), %rsi     # 0x13dc22
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x412e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60185
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60161
jmp 0x60183
leaq 0xddb34(%rip), %rdi     # 0x13dc9c
leaq 0xddab3(%rip), %rsi     # 0x13dc22
movl $0x2c4, %edx            # imm = 0x2C4
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x6018d
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlPrev
void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
    unsigned char *_eptr, *_sptr;
    serverAssert(*eptr != NULL && *sptr != NULL);

    _sptr = ziplistPrev(zl,*eptr);
    if (_sptr != NULL) {
        _eptr = ziplistPrev(zl,_sptr);
        serverAssert(_eptr != NULL);
    } else {
        /* No previous entry. */
        _eptr = NULL;
    }

    *eptr = _eptr;
    *sptr = _sptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x601da
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x601da
jmp 0x601fc
leaq 0xdda9c(%rip), %rdi     # 0x13dc7d
leaq 0xdda3a(%rip), %rsi     # 0x13dc22
movl $0x2d2, %edx            # imm = 0x2D2
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x41350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60255
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41350
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60231
jmp 0x60253
leaq 0xdda72(%rip), %rdi     # 0x13dcaa
leaq 0xdd9e3(%rip), %rsi     # 0x13dc22
movl $0x2d7, %edx            # imm = 0x2D7
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x6025d
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlIsInRange
int zzlIsInRange(unsigned char *zl, zrangespec *range) {
    unsigned char *p;
    double score;

    /* Test for ranges that will always be empty. */
    if (range->min > range->max ||
            (range->min == range->max && (range->minex || range->maxex)))
        return 0;

    p = ziplistIndex(zl,-1); /* Last score. */
    if (p == NULL) return 0; /* Empty sorted set */
    score = zzlGetScore(p);
    if (!zslValueGteMin(score,range))
        return 0;

    p = ziplistIndex(zl,1); /* First score. */
    serverAssert(p != NULL);
    score = zzlGetScore(p);
    if (!zslValueLteMax(score,range))
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
ja 0x602cc
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x602d8
jp 0x602d8
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x602cc
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x602d8
movl $0x0, -0x4(%rbp)
jmp 0x60395
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x41120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x602fd
movl $0x0, -0x4(%rbp)
jmp 0x60395
movq -0x20(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
jne 0x60327
movl $0x0, -0x4(%rbp)
jmp 0x60395
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60342
jmp 0x60364
leaq 0xdd96f(%rip), %rdi     # 0x13dcb8
leaq 0xdd8d2(%rip), %rsi     # 0x13dc22
movl $0x2f3, %edx            # imm = 0x2F3
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
jne 0x6038e
movl $0x0, -0x4(%rbp)
jmp 0x60395
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60280
cmpl $0x0, %eax
jne 0x603de
movq $0x0, -0x8(%rbp)
jmp 0x6048d
jmp 0x603e0
cmpq $0x0, -0x20(%rbp)
je 0x60485
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60405
jmp 0x60427
leaq 0xddbc6(%rip), %rdi     # 0x13dfd2
leaq 0xdd80f(%rip), %rsi     # 0x13dc22
movl $0x306, %edx            # imm = 0x306
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x28(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
je 0x6046f
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
je 0x60465
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6048d
movq $0x0, -0x8(%rbp)
jmp 0x6048d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x20(%rbp)
jmp 0x603e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60280
cmpl $0x0, %eax
jne 0x604e1
movq $0x0, -0x8(%rbp)
jmp 0x605dc
jmp 0x604e3
cmpq $0x0, -0x20(%rbp)
je 0x605d4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60508
jmp 0x6052a
leaq 0xddac3(%rip), %rdi     # 0x13dfd2
leaq 0xdd70c(%rip), %rsi     # 0x13dc22
movl $0x322, %edx            # imm = 0x322
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x28(%rbp), %rdi
callq 0x5fe60
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
je 0x60572
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
je 0x60568
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x605dc
movq $0x0, -0x8(%rbp)
jmp 0x605dc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x605c7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41350
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x605a3
jmp 0x605c5
leaq 0xdd718(%rip), %rdi     # 0x13dcc2
leaq 0xdd671(%rip), %rsi     # 0x13dc22
movl $0x330, %edx            # imm = 0x330
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x605cf
movq $0x0, -0x20(%rbp)
jmp 0x604e3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: zzlIsInLexRange
int zzlIsInLexRange(unsigned char *zl, zlexrangespec *range) {
    unsigned char *p;

    /* Test for ranges that will always be empty. */
    if (compareStringObjectsForLexRange(range->min,range->max) > 1 ||
            (compareStringObjects(range->min,range->max) == 0 &&
            (range->minex || range->maxex)))
        return 0;

    p = ziplistIndex(zl,-2); /* Last element. */
    if (p == NULL) return 0;
    if (!zzlLexValueGteMin(p,range))
        return 0;

    p = ziplistIndex(zl,0); /* First element. */
    serverAssert(p != NULL);
    if (!zzlLexValueLteMax(p,range))
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5fa70
cmpl $0x1, %eax
jg 0x60646
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x497e0
cmpl $0x0, %eax
jne 0x60652
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x60646
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x60652
movl $0x0, -0x4(%rbp)
jmp 0x606eb
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x60674
movl $0x0, -0x4(%rbp)
jmp 0x606eb
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60700
cmpl $0x0, %eax
jne 0x6068f
movl $0x0, -0x4(%rbp)
jmp 0x606eb
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x606a7
jmp 0x606c9
leaq 0xdd60a(%rip), %rdi     # 0x13dcb8
leaq 0xdd56d(%rip), %rsi     # 0x13dc22
movl $0x357, %edx            # imm = 0x357
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60740
cmpl $0x0, %eax
jne 0x606e4
movl $0x0, -0x4(%rbp)
jmp 0x606eb
movl $0x1, -0x4(%rbp)
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: zzlLexValueGteMin
static int zzlLexValueGteMin(unsigned char *p, zlexrangespec *spec) {
    robj *value = ziplistGetObject(p);
    int res = zslLexValueGteMin(value,spec);
    decrRefCount(value);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ff40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f280
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f70
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlLexValueLteMax
static int zzlLexValueLteMax(unsigned char *p, zlexrangespec *spec) {
    robj *value = ziplistGetObject(p);
    int res = zslLexValueLteMax(value,spec);
    decrRefCount(value);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ff40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f2f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f70
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlFirstInLexRange
unsigned char *zzlFirstInLexRange(unsigned char *zl, zlexrangespec *range) {
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;

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

    while (eptr != NULL) {
        if (zzlLexValueGteMin(eptr,range)) {
            /* Check if score <= max. */
            if (zzlLexValueLteMax(eptr,range))
                return eptr;
            return NULL;
        }

        /* Move to next element. */
        sptr = ziplistNext(zl,eptr); /* This element score. Skip it. */
        serverAssert(sptr != NULL);
        eptr = ziplistNext(zl,sptr); /* Next element. */
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x605f0
cmpl $0x0, %eax
jne 0x607be
movq $0x0, -0x8(%rbp)
jmp 0x6085d
jmp 0x607c0
cmpq $0x0, -0x20(%rbp)
je 0x60855
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60700
cmpl $0x0, %eax
je 0x60803
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60740
cmpl $0x0, %eax
je 0x607f9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6085d
movq $0x0, -0x8(%rbp)
jmp 0x6085d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6081d
jmp 0x6083f
leaq 0xdd7ae(%rip), %rdi     # 0x13dfd2
leaq 0xdd3f7(%rip), %rsi     # 0x13dc22
movl $0x370, %edx            # imm = 0x370
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x20(%rbp)
jmp 0x607c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlLastInLexRange
unsigned char *zzlLastInLexRange(unsigned char *zl, zlexrangespec *range) {
    unsigned char *eptr = ziplistIndex(zl,-2), *sptr;

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

    while (eptr != NULL) {
        if (zzlLexValueLteMax(eptr,range)) {
            /* Check if score >= min. */
            if (zzlLexValueGteMin(eptr,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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x41120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x605f0
cmpl $0x0, %eax
jne 0x608b1
movq $0x0, -0x8(%rbp)
jmp 0x60960
jmp 0x608b3
cmpq $0x0, -0x20(%rbp)
je 0x60958
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60740
cmpl $0x0, %eax
je 0x608f6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60700
cmpl $0x0, %eax
je 0x608ec
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60960
movq $0x0, -0x8(%rbp)
jmp 0x60960
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6094b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41350
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x60927
jmp 0x60949
leaq 0xdd394(%rip), %rdi     # 0x13dcc2
leaq 0xdd2ed(%rip), %rsi     # 0x13dc22
movl $0x38b, %edx            # imm = 0x38B
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x60953
movq $0x0, -0x20(%rbp)
jmp 0x608b3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zzlFind
unsigned char *zzlFind(unsigned char *zl, robj *ele, double *score) {
    unsigned char *eptr = ziplistIndex(zl,0), *sptr;

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

        if (ziplistCompare(eptr,ele->ptr,sdslen(ele->ptr))) {
            /* Matching element, pull out score. */
            if (score != NULL) *score = zzlGetScore(sptr);
            decrRefCount(ele);
            return eptr;
        }

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

    decrRefCount(ele);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x494f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x60a66
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x609c5
jmp 0x609f0
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xdd5fe(%rip), %rdx     # 0x13dfd2
leaq 0xdd247(%rip), %rcx     # 0x13dc22
movl $0x399, %r8d            # imm = 0x399
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5f9b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0x41630
cmpl $0x0, %eax
je 0x60a50
cmpq $0x0, -0x20(%rbp)
je 0x60a3d
movq -0x30(%rbp), %rdi
callq 0x5fe60
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x48f70
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x60a77
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
jmp 0x609a0
movq -0x18(%rbp), %rdi
callq 0x48f70
movq $0x0, -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: zzlDelete
unsigned char *zzlDelete(unsigned char *zl, unsigned char *eptr) {
    unsigned char *p = eptr;

    /* TODO: add function to ziplist API to delete N elements from offset. */
    zl = ziplistDelete(zl,&p);
    zl = ziplistDelete(zl,&p);
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x41570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x41570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)