LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: unblockClientWaitingData
void unblockClientWaitingData(client *c) {
    dictEntry *de;
    dictIterator *di;
    list *l;

    serverAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0);
    di = dictGetIterator(c->bpop.keys);
    /* The client may wait for multiple keys, so unblock it for every key. */
    while((de = dictNext(di)) != NULL) {
        robj *key = dictGetKey(de);

        /* Remove this client from the list of clients waiting for this key. */
        l = dictFetchValue(c->db->blocking_keys,key);
        serverAssertWithInfo(c,key,l != NULL);
        listDelNode(l,listSearchKey(l,c));
        /* If the list is empty we need to remove it to avoid wasting memory */
        if (listLength(l) == 0)
            dictDelete(c->db->blocking_keys,key);
    }
    dictReleaseIterator(di);

    /* Cleanup the client structure */
    dictEmpty(c->bpop.keys,NULL);
    if (c->bpop.target) {
        decrRefCount(c->bpop.target);
        c->bpop.target = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x178(%rcx), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
je 0x5ac62
jmp 0x5ac8d
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xe2e03(%rip), %rdx     # 0x13da74
leaq 0xe2d2c(%rip), %rcx     # 0x13d9a4
movl $0x290, %r8d            # imm = 0x290
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
callq 0x2e400
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5ad56
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2e280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5ace5
jmp 0x5ad10
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0xe2d9c(%rip), %rdx     # 0x13da90
leaq 0xe2ca9(%rip), %rcx     # 0x13d9a4
movl $0x298, %r8d            # imm = 0x298
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x274d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x271e0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x5ad51
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2de50
jmp 0x5aca1
movq -0x18(%rbp), %rdi
callq 0x2e600
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2ed40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x180(%rax)
je 0x5ada0
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0x48f70
movq -0x8(%rbp), %rax
movq $0x0, 0x180(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: signalListAsReady
void signalListAsReady(redisDb *db, robj *key) {
    readyList *rl;

    /* No clients blocking for this key? No need to queue it. */
    if (dictFind(db->blocking_keys,key) == NULL) return;

    /* Key was already signaled? No need to queue it again. */
    if (dictFind(db->ready_keys,key) != NULL) return;

    /* Ok, we need to queue this key into server.ready_keys. */
    rl = zmalloc(sizeof(*rl));
    rl->key = key;
    rl->db = db;
    incrRefCount(key);
    listAddNodeTail(server.ready_keys,rl);

    /* We also add the key in the db->ready_keys dictionary in order
     * to avoid adding it multiple times into a list with a simple O(1)
     * check. */
    incrRefCount(key);
    serverAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dcb0
cmpq $0x0, %rax
jne 0x5addc
jmp 0x5ae84
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dcb0
cmpq $0x0, %rax
je 0x5adf8
jmp 0x5ae84
movl $0x10, %edi
callq 0x3acd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x487b0
leaq 0x11d3ab(%rip), %rax    # 0x1781d8
movq 0x928(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x27000
movq -0x10(%rbp), %rdi
callq 0x487b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d8c0
cmpl $0x0, %eax
jne 0x5ae62
jmp 0x5ae84
leaq 0xe2c31(%rip), %rdi     # 0x13da9a
leaq 0xe2b34(%rip), %rsi     # 0x13d9a4
movl $0x2c3, %edx            # imm = 0x2C3
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: brpoplpushCommand
void brpoplpushCommand(client *c) {
    mstime_t timeout;

    if (getTimeoutFromObjectOrReply(c,c->argv[3],&timeout,UNIT_SECONDS)
        != C_OK) return;

    robj *key = lookupKeyWrite(c->db, c->argv[1]);

    if (key == NULL) {
        if (c->flags & CLIENT_MULTI) {
            /* Blocking against an empty list in a multi state
             * returns immediately. */
            addReply(c, shared.nullbulk);
        } else {
            /* The list is empty and the client blocks. */
            blockForKeys(c, c->argv + 1, 1, timeout, c->argv[2]);
        }
    } else {
        if (key->type != OBJ_LIST) {
            addReply(c, shared.wrongtypeerr);
        } else {
            /* The list exists and has elements, so
             * the regular rpoplpushCommand is executed. */
            serverAssertWithInfo(c,key,listTypeLength(key) > 0);
            rpoplpushCommand(c);
        }
    }
}

// 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 0x18(%rax), %rsi
leaq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0x9d6d0
cmpl $0x0, %eax
je 0x5b621
jmp 0x5b704
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4a6f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b699
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5b66d
movq -0x8(%rbp), %rdi
leaq 0x11d5de(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x5b697
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %r8
movl $0x1, %edx
callq 0x5aab0
jmp 0x5b704
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x1, %eax
je 0x5b6bd
movq -0x8(%rbp), %rdi
leaq 0x11d58e(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
jmp 0x5b702
movq -0x18(%rbp), %rdi
callq 0x59140
cmpq $0x0, %rax
jbe 0x5b6ce
jmp 0x5b6f9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xe23f7(%rip), %rdx     # 0x13dad4
leaq 0xe22c0(%rip), %rcx     # 0x13d9a4
movl $0x3be, %r8d            # imm = 0x3BE
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rdi
callq 0x5a900
jmp 0x5b704
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: setTypeConvert
void setTypeConvert(robj *setobj, int enc) {
    setTypeIterator *si;
    serverAssertWithInfo(NULL,setobj,setobj->type == OBJ_SET &&
                             setobj->encoding == OBJ_ENCODING_INTSET);

    if (enc == OBJ_ENCODING_HT) {
        int64_t intele;
        dict *d = dictCreate(&setDictType,NULL);
        robj *element;

        /* Presize the dict to avoid rehashing */
        dictExpand(d,intsetLen(setobj->ptr));

        /* To add the elements we extract integers and create redis objects */
        si = setTypeInitIterator(setobj);
        while (setTypeNext(si,&element,&intele) != -1) {
            element = createStringObjectFromLongLong(intele);
            serverAssertWithInfo(NULL,element,
                                dictAdd(d,element,NULL) == DICT_OK);
        }
        setTypeReleaseIterator(si);

        setobj->encoding = OBJ_ENCODING_HT;
        zfree(setobj->ptr);
        setobj->ptr = d;
    } else {
        serverPanic("Unsupported set conversion");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x5b900
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x5b900
jmp 0x5b92b
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xe224c(%rip), %rdx     # 0x13db5b
leaq 0xe2202(%rip), %rcx     # 0x13db18
movl $0xf5, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
cmpl $0x2, -0xc(%rbp)
jne 0x5ba15
leaq 0x11b474(%rip), %rdi    # 0x176db0
xorl %eax, %eax
movl %eax, %esi
callq 0x2d330
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7ba20
movq -0x38(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x2d440
movq -0x8(%rbp), %rdi
callq 0x5bbf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bce0
cmpl $-0x1, %eax
je 0x5b9e0
movq -0x20(%rbp), %rdi
callq 0x486f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d8c0
cmpl $0x0, %eax
jne 0x5b9b3
jmp 0x5b9de
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xe21dc(%rip), %rdx     # 0x13db9e
leaq 0xe214f(%rip), %rcx     # 0x13db18
movl $0x104, %r8d            # imm = 0x104
callq 0x78360
movl $0x1, %edi
callq 0x263c0
jmp 0x5b978
movq -0x18(%rbp), %rdi
callq 0x5bca0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
orl $0x20, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3afa0
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5ba37
leaq 0xe21a5(%rip), %rdi     # 0x13dbc1
leaq 0xe20f5(%rip), %rsi     # 0x13db18
movl $0x10c, %edx            # imm = 0x10C
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: setTypeRemove
int setTypeRemove(robj *setobj, robj *value) {
    long long llval;
    if (setobj->encoding == OBJ_ENCODING_HT) {
        if (dictDelete(setobj->ptr,value) == DICT_OK) {
            if (htNeedsResize(setobj->ptr)) dictResize(setobj->ptr);
            return 1;
        }
    } else if (setobj->encoding == OBJ_ENCODING_INTSET) {
        if (isObjectRepresentableAsLongLong(value,&llval) == C_OK) {
            int success;
            setobj->ptr = intsetRemove(setobj->ptr,llval,&success);
            if (success) return 1;
        }
    } else {
        serverPanic("Unknown set encoding");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x5baa4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2de50
cmpl $0x0, %eax
jne 0x5baa2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30420
cmpl $0x0, %eax
je 0x5ba96
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2d3e0
movl $0x1, -0x4(%rbp)
jmp 0x5bb25
jmp 0x5bb1e
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x5bafa
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x490f0
cmpl $0x0, %eax
jne 0x5baf8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x7b840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x5baf6
movl $0x1, -0x4(%rbp)
jmp 0x5bb25
jmp 0x5baf8
jmp 0x5bb1c
leaq 0xe16fc(%rip), %rdi     # 0x13d1fd
leaq 0xe2010(%rip), %rsi     # 0x13db18
movl $0x66, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x5bb1e
movl $0x0, -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_set.c
// Function: setTypeIsMember
int setTypeIsMember(robj *subject, robj *value) {
    long long llval;
    if (subject->encoding == OBJ_ENCODING_HT) {
        return dictFind((dict*)subject->ptr,value) != NULL;
    } else if (subject->encoding == OBJ_ENCODING_INTSET) {
        if (isObjectRepresentableAsLongLong(value,&llval) == C_OK) {
            return intsetFind((intset*)subject->ptr,llval);
        }
    } else {
        serverPanic("Unknown set encoding");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x5bb73
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2dcb0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5bbdc
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x5bbb1
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x490f0
cmpl $0x0, %eax
jne 0x5bbaf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b900
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x5bbdc
jmp 0x5bbd3
leaq 0xe1645(%rip), %rdi     # 0x13d1fd
leaq 0xe1f59(%rip), %rsi     # 0x13db18
movl $0x74, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x5bbd5
movl $0x0, -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_set.c
// Function: setTypeInitIterator
setTypeIterator *setTypeInitIterator(robj *subject) {
    setTypeIterator *si = zmalloc(sizeof(setTypeIterator));
    si->subject = subject;
    si->encoding = subject->encoding;
    if (si->encoding == OBJ_ENCODING_HT) {
        si->di = dictGetIterator(subject->ptr);
    } else if (si->encoding == OBJ_ENCODING_INTSET) {
        si->ii = 0;
    } else {
        serverPanic("Unknown set encoding");
    }
    return si;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x3acd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x5bc4c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5bc87
movq -0x10(%rbp), %rax
cmpl $0x6, 0x8(%rax)
jne 0x5bc63
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x5bc85
leaq 0xe1593(%rip), %rdi     # 0x13d1fd
leaq 0xe1ea7(%rip), %rsi     # 0x13db18
movl $0x82, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x5bc87
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: setTypeNext
int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele) {
    if (si->encoding == OBJ_ENCODING_HT) {
        dictEntry *de = dictNext(si->di);
        if (de == NULL) return -1;
        *objele = dictGetKey(de);
        *llele = -123456789; /* Not needed. Defensive. */
    } else if (si->encoding == OBJ_ENCODING_INTSET) {
        if (!intsetGet(si->subject->ptr,si->ii++,llele))
            return -1;
        *objele = NULL; /* Not needed. Defensive. */
    } else {
        serverPanic("Wrong set encoding in setTypeNext");
    }
    return si->encoding;
}

// 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
cmpl $0x2, 0x8(%rax)
jne 0x5bd3d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2e4a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5bd22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bdb2
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $-0x75bcd15, (%rax)     # imm = 0xF8A432EB
jmp 0x5bda8
movq -0x10(%rbp), %rax
cmpl $0x6, 0x8(%rax)
jne 0x5bd84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rdx
callq 0x7b9d0
cmpb $0x0, %al
jne 0x5bd77
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bdb2
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x5bda6
leaq 0xe1d95(%rip), %rdi     # 0x13db20
leaq 0xe1d86(%rip), %rsi     # 0x13db18
movl $0xa7, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x5bda8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: setTypeNextObject
robj *setTypeNextObject(setTypeIterator *si) {
    int64_t intele;
    robj *objele;
    int encoding;

    encoding = setTypeNext(si,&objele,&intele);
    switch(encoding) {
        case -1:    return NULL;
        case OBJ_ENCODING_INTSET:
            return createStringObjectFromLongLong(intele);
        case OBJ_ENCODING_HT:
            incrRefCount(objele);
            return objele;
        default:
            serverPanic("Unsupported encoding");
    }
    return NULL; /* just to suppress warnings */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bce0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $-0x1, %eax
je 0x5be01
jmp 0x5bded
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x5be1a
jmp 0x5bdf7
movl -0x28(%rbp), %eax
subl $0x6, %eax
je 0x5be0b
jmp 0x5be2d
movq $0x0, -0x8(%rbp)
jmp 0x5be4f
movq -0x18(%rbp), %rdi
callq 0x486f0
movq %rax, -0x8(%rbp)
jmp 0x5be4f
movq -0x20(%rbp), %rdi
callq 0x487b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5be4f
leaq 0xe1d10(%rip), %rdi     # 0x13db44
leaq 0xe1cdd(%rip), %rsi     # 0x13db18
movl $0xc1, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
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_set.c
// Function: setTypeRandomElement
int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele) {
    if (setobj->encoding == OBJ_ENCODING_HT) {
        dictEntry *de = dictGetRandomKey(setobj->ptr);
        *objele = dictGetKey(de);
        *llele = -123456789; /* Not needed. Defensive. */
    } else if (setobj->encoding == OBJ_ENCODING_INTSET) {
        *llele = intsetRandom(setobj->ptr);
        *objele = NULL; /* Not needed. Defensive. */
    } else {
        serverPanic("Unknown set encoding");
    }
    return setobj->encoding;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x5beb1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e6a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $-0x75bcd15, (%rax)     # imm = 0xF8A432EB
jmp 0x5bf0a
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x5bee6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7b960
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x5bf08
leaq 0xe1310(%rip), %rdi     # 0x13d1fd
leaq 0xe1c24(%rip), %rsi     # 0x13db18
movl $0xe0, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x5bf0a
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: setTypeSize
unsigned long setTypeSize(robj *subject) {
    if (subject->encoding == OBJ_ENCODING_HT) {
        return dictSize((dict*)subject->ptr);
    } else if (subject->encoding == OBJ_ENCODING_INTSET) {
        return intsetLen((intset*)subject->ptr);
    } else {
        serverPanic("Unknown set encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x5bf5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0x48(%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x5bfa3
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x5bf81
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7ba20
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x5bfa3
leaq 0xe1275(%rip), %rdi     # 0x13d1fd
leaq 0xe1b89(%rip), %rsi     # 0x13db18
movl $0xeb, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: saddCommand
void saddCommand(client *c) {
    robj *set;
    int j, added = 0;

    set = lookupKeyWrite(c->db,c->argv[1]);
    if (set == NULL) {
        set = setTypeCreate(c->argv[2]);
        dbAdd(c->db,c->argv[1],set);
    } else {
        if (set->type != OBJ_SET) {
            addReply(c,shared.wrongtypeerr);
            return;
        }
    }

    for (j = 2; j < c->argc; j++) {
        c->argv[j] = tryObjectEncoding(c->argv[j]);
        if (setTypeAdd(set,c->argv[j])) added++;
    }
    if (added) {
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_SET,"sadd",c->argv[1],c->db->id);
    }
    server.dirty += added;
    addReplyLongLong(c,added);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4a6f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5c01b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x5b710
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x4a7d0
jmp 0x5c044
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x5c042
movq -0x8(%rbp), %rdi
leaq 0x11cc0c(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
jmp 0x5c127
jmp 0x5c044
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x5c0b3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x491b0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5b750
cmpl $0x0, %eax
je 0x5c0a6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c0a8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5c04b
cmpl $0x0, -0x18(%rbp)
je 0x5c0fa
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x20, %edi
leaq 0xdb490(%rip), %rsi     # 0x137585
callq 0x9ce20
movslq -0x18(%rbp), %rcx
leaq 0x11c0d3(%rip), %rax    # 0x1781d8
addq 0x720(%rax), %rcx
leaq 0x11c0c5(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: sremCommand
void sremCommand(client *c) {
    robj *set;
    int j, deleted = 0, keyremoved = 0;

    if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,set,OBJ_SET)) return;

    for (j = 2; j < c->argc; j++) {
        if (setTypeRemove(set,c->argv[j])) {
            deleted++;
            if (setTypeSize(set) == 0) {
                dbDelete(c->db,c->argv[1]);
                keyremoved = 1;
                break;
            }
        }
    }
    if (deleted) {
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_SET,"srem",c->argv[1],c->db->id);
        if (keyremoved)
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",c->argv[1],
                                c->db->id);
        server.dirty += deleted;
    }
    addReplyLongLong(c,deleted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11cadf(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5c18b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5c190
jmp 0x5c2b0
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x5c20a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5ba40
cmpl $0x0, %eax
je 0x5c1fd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5bf20
cmpq $0x0, %rax
jne 0x5c1fb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4ac10
movl $0x1, -0x1c(%rbp)
jmp 0x5c20a
jmp 0x5c1fd
jmp 0x5c1ff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5c197
cmpl $0x0, -0x18(%rbp)
je 0x5c2a3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x20, %edi
leaq 0xdb33a(%rip), %rsi     # 0x13758a
callq 0x9ce20
cmpl $0x0, -0x1c(%rbp)
je 0x5c283
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0xdd21a(%rip), %rsi     # 0x139498
callq 0x9ce20
movslq -0x18(%rbp), %rcx
leaq 0x11bf4a(%rip), %rax    # 0x1781d8
addq 0x720(%rax), %rcx
leaq 0x11bf3c(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: sismemberCommand
void sismemberCommand(client *c) {
    robj *set;

    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,set,OBJ_SET)) return;

    c->argv[2] = tryObjectEncoding(c->argv[2]);
    if (setTypeIsMember(set,c->argv[2]))
        addReply(c,shared.cone);
    else
        addReply(c,shared.czero);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11c69d(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5c5cd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5c5cf
jmp 0x5c633
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x491b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x5bb30
cmpl $0x0, %eax
je 0x5c61f
movq -0x8(%rbp), %rdi
leaq 0x11c62c(%rip), %rax    # 0x178c40
movq 0x28(%rax), %rsi
callq 0x42cc0
jmp 0x5c633
movq -0x8(%rbp), %rdi
leaq 0x11c616(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rsi
callq 0x42cc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: scardCommand
void scardCommand(client *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_SET)) return;

    addReplyLongLong(c,setTypeSize(o));
}

// 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 0x8(%rax), %rsi
leaq 0x11c5dd(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5c68d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5c68f
jmp 0x5c6ac
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5bf20
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: srandmemberCommand
void srandmemberCommand(client *c) {
    robj *set, *ele;
    int64_t llele;
    int encoding;

    if (c->argc == 3) {
        srandmemberWithCountCommand(c);
        return;
    } else if (c->argc > 3) {
        addReply(c,shared.syntaxerr);
        return;
    }

    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,set,OBJ_SET)) return;

    encoding = setTypeRandomElement(set,&ele,&llele);
    if (encoding == OBJ_ENCODING_INTSET) {
        addReplyBulkLongLong(c,llele);
    } else {
        addReplyBulk(c,ele);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jne 0x5d6e4
movq -0x8(%rbp), %rdi
callq 0x5d320
jmp 0x5d782
movq -0x8(%rbp), %rax
cmpl $0x3, 0x38(%rax)
jle 0x5d707
movq -0x8(%rbp), %rdi
leaq 0x11b547(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x5d782
jmp 0x5d709
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11b520(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5d74a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5d74c
jmp 0x5d782
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5be60
movl %eax, -0x24(%rbp)
cmpl $0x6, -0x24(%rbp)
jne 0x5d775
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x439f0
jmp 0x5d782
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43630
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_set.c
// Function: sscanCommand
void sscanCommand(client *c) {
    robj *set;
    unsigned long cursor;

    if (parseScanCursorOrReply(c,c->argv[2],&cursor) == C_ERR) return;
    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.emptyscan)) == NULL ||
        checkType(c,set,OBJ_SET)) return;
    scanGenericCommand(c,set,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 0x5defc
jmp 0x5df53
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11ad2d(%rip), %rax    # 0x178c40
movq 0x148(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5df40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5df42
jmp 0x5df53
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_zset.c
// Function: zslCreateNode
zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
    zskiplistNode *zn = zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
    zn->score = score;
    zn->obj = obj;
    return zn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x4, %rdi
addq $0x18, %rdi
callq 0x3acd0
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%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: zslCreate
zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;

    zsl = zmalloc(sizeof(*zsl));
    zsl->level = 1;
    zsl->length = 0;
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        zsl->header->level[j].forward = NULL;
        zsl->header->level[j].span = 0;
    }
    zsl->header->backward = NULL;
    zsl->tail = NULL;
    return zsl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x3acd0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x20, %edi
xorps %xmm0, %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x5df60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0x5e04a
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5dfff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslFree
void zslFree(zskiplist *zsl) {
    zskiplistNode *node = zsl->header->level[0].forward, *next;

    zfree(zsl->header);
    while(node) {
        next = node->level[0].forward;
        zslFreeNode(node);
        node = next;
    }
    zfree(zsl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3afa0
cmpq $0x0, -0x10(%rbp)
je 0x5e0ed
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5e070
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5e0c7
movq -0x8(%rbp), %rdi
callq 0x3afa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslRandomLevel
int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
callq 0x26a30
andq $0xffff, %rax           # imm = 0xFFFF
cvtsi2sd %rax, %xmm1
movsd 0xdfad1(%rip), %xmm0    # 0x13dbf8
ucomisd %xmm1, %xmm0
jbe 0x5e138
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5e10f
cmpl $0x20, -0x4(%rbp)
jge 0x5e146
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x5e150
movl $0x20, %eax
movl %eax, -0x8(%rbp)
jmp 0x5e150
movl -0x8(%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: zslDeleteNode
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    for (i = 0; i < zsl->level; i++) {
        if (update[i]->level[i].forward == x) {
            update[i]->level[i].span += x->level[i].span - 1;
            update[i]->level[i].forward = x->level[i].forward;
        } else {
            update[i]->level[i].span -= 1;
        }
    }
    if (x->level[0].forward) {
        x->level[0].forward->backward = x->backward;
    } else {
        zsl->tail = x->backward;
    }
    while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
        zsl->level--;
    zsl->length--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5e75f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x5e72b
movq -0x10(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x5e74f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x5e751
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e687
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5e780
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x5e790
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5e792
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x18(%rcx)
movb %al, -0x1d(%rbp)
jle 0x5e7ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x5e7d3
jmp 0x5e7e2
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x5e792
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslDelete
int zslDelete(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x12c(%rbp)
cmpl $0x0, -0x12c(%rbp)
jl 0x5e980
jmp 0x5e845
movq -0x128(%rbp), %rcx
addq $0x18, %rcx
movslq -0x12c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x12d(%rbp)
je 0x5e922
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x12c(%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, -0x12e(%rbp)
ja 0x5e916
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
xorl %eax, %eax
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x12f(%rbp)
jne 0x5e90a
jp 0x5e90a
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x497e0
cmpl $0x0, %eax
setl %al
movb %al, -0x12f(%rbp)
movb -0x12f(%rbp), %al
movb %al, -0x12e(%rbp)
movb -0x12e(%rbp), %al
movb %al, -0x12d(%rbp)
movb -0x12d(%rbp), %al
testb $0x1, %al
jne 0x5e92e
jmp 0x5e956
movq -0x128(%rbp), %rax
addq $0x18, %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
jmp 0x5e845
movq -0x128(%rbp), %rcx
movslq -0x12c(%rbp), %rax
movq %rcx, -0x120(%rbp,%rax,8)
movl -0x12c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x5e836
movq -0x128(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x5e9f5
movsd -0x18(%rbp), %xmm0
movq -0x128(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x5e9f5
jp 0x5e9f5
movq -0x128(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x49840
cmpl $0x0, %eax
je 0x5e9f5
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x5e670
movq -0x128(%rbp), %rdi
callq 0x5e070
movl $0x1, -0x4(%rbp)
jmp 0x5e9fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslIsInRange
int zslIsInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;

    /* Test for ranges that will always be empty. */
    if (range->min > range->max ||
            (range->min == range->max && (range->minex || range->maxex)))
        return 0;
    x = zsl->tail;
    if (x == NULL || !zslValueGteMin(x->score,range))
        return 0;
    x = zsl->header->level[0].forward;
    if (x == NULL || !zslValueLteMax(x->score,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
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
ja 0x5eabc
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x5eac5
jp 0x5eac5
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x5eabc
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x5eac5
movl $0x0, -0x4(%rbp)
jmp 0x5eb35
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5eaef
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
jne 0x5eaf8
movl $0x0, -0x4(%rbp)
jmp 0x5eb35
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5eb25
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
jne 0x5eb2e
movl $0x0, -0x4(%rbp)
jmp 0x5eb35
movl $0x1, -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: zslFirstInRange
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ea70
cmpl $0x0, %eax
jne 0x5ebbf
movq $0x0, -0x8(%rbp)
jmp 0x5ecc5
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 0x5ec65
jmp 0x5ebe3
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 0x5ec30
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x5ec39
jmp 0x5ec55
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 0x5ebe3
jmp 0x5ec57
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ebd7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5ec7a
jmp 0x5ec9c
leaq 0xdefaa(%rip), %rdi     # 0x13dc2b
leaq 0xdef9a(%rip), %rsi     # 0x13dc22
movl $0x100, %edx            # imm = 0x100
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
jne 0x5ecbd
movq $0x0, -0x8(%rbp)
jmp 0x5ecc5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zslLastInRange
zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ea70
cmpl $0x0, %eax
jne 0x5ecff
movq $0x0, -0x8(%rbp)
jmp 0x5edf7
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 0x5eda3
jmp 0x5ed23
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 0x5ed6e
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ea10
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x5ed77
jmp 0x5ed93
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 0x5ed23
jmp 0x5ed95
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ed17
cmpq $0x0, -0x20(%rbp)
je 0x5edac
jmp 0x5edce
leaq 0xdee78(%rip), %rdi     # 0x13dc2b
leaq 0xdee68(%rip), %rsi     # 0x13dc22
movl $0x119, %edx            # imm = 0x119
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5eb40
cmpl $0x0, %eax
jne 0x5edef
movq $0x0, -0x8(%rbp)
jmp 0x5edf7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)