LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: pushxGenericCommand
void pushxGenericCommand(client *c, robj *refval, robj *val, int where) {
    robj *subject;
    listTypeIterator *iter;
    listTypeEntry entry;
    int inserted = 0;

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

    if (refval != NULL) {
        /* Seek refval from head to tail */
        iter = listTypeInitIterator(subject,0,LIST_TAIL);
        while (listTypeNext(iter,&entry)) {
            if (listTypeEqual(&entry,refval)) {
                listTypeInsert(&entry,val,where);
                inserted = 1;
                break;
            }
        }
        listTypeReleaseIterator(iter);

        if (inserted) {
            signalModifiedKey(c->db,c->argv[1]);
            notifyKeyspaceEvent(NOTIFY_LIST,"linsert",
                                c->argv[1],c->db->id);
            server.dirty++;
        } else {
            /* Notify client of a failed insert */
            addReply(c,shared.cnegone);
            return;
        }
    } else {
        char *event = (where == LIST_HEAD) ? "lpush" : "rpush";

        listTypePush(subject,val,where);
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_LIST,event,c->argv[1],c->db->id);
        server.dirty++;
    }

    addReplyLongLong(c,listTypeLength(subject));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb7149(%rip), %rax     # 0x1072b0
movq 0x20(%rax), %rdx
callq 0x44fbb
testq %rax, %rax
je 0x50297
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
jne 0x50297
testq %r12, %r12
je 0x50202
movq %r15, 0x8(%rsp)
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4fc5a
movq %rax, %r13
leaq 0x10(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x4fcf2
testl %eax, %eax
je 0x50273
movq %r15, %rdi
movq %r12, %rsi
callq 0x4fe5a
testl %eax, %eax
je 0x501b5
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x4fda0
movq 0x10(%r13), %rdi
callq 0x3b3df
movq %r13, %rdi
callq 0x3b3df
leaq 0x6f379(%rip), %r12     # 0xbf579
jmp 0x50223
testl %ebp, %ebp
leaq 0x6f387(%rip), %rax     # 0xbf592
leaq 0x6f353(%rip), %r12     # 0xbf565
cmoveq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4faf0
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
movl $0x10, %edi
movq %r12, %rsi
callq 0x800c9
leaq 0xb6601(%rip), %rax     # 0x106858
incq 0x710(%rax)
movq %r14, %rdi
callq 0x4fc1c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40606
jmp 0x50297
movq 0x10(%r13), %rdi
callq 0x3b3df
movq %r13, %rdi
callq 0x3b3df
leaq 0xb7025(%rip), %rax     # 0x1072b0
movq 0x30(%rax), %rsi
movq %rbx, %rdi
callq 0x3fc19
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: linsertCommand
void linsertCommand(client *c) {
    c->argv[4] = tryObjectEncoding(c->argv[4]);
    if (strcasecmp(c->argv[2]->ptr,"after") == 0) {
        pushxGenericCommand(c,c->argv[3],c->argv[4],LIST_TAIL);
    } else if (strcasecmp(c->argv[2]->ptr,"before") == 0) {
        pushxGenericCommand(c,c->argv[3],c->argv[4],LIST_HEAD);
    } else {
        addReply(c,shared.syntaxerr);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x20(%rax), %rdi
callq 0x4426d
movq 0x40(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x40(%rbx), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
leaq 0x76028(%rip), %rsi     # 0xc635d
movq %r14, %rdi
callq 0x26300
testl %eax, %eax
je 0x5036f
leaq 0x7601b(%rip), %rsi     # 0xc6363
movq %r14, %rdi
callq 0x26300
testl %eax, %eax
je 0x50381
leaq 0xb6f55(%rip), %rax     # 0x1072b0
movq 0x80(%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3fc19
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
jmp 0x5038e
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x5013f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: lindexCommand
void lindexCommand(client *c) {
    robj *o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;
    long index;
    robj *value = NULL;

    if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
        return;

    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklistEntry entry;
        if (quicklistIndex(o->ptr, index, &entry)) {
            if (entry.value) {
                value = createStringObject((char*)entry.value,entry.sz);
            } else {
                value = createStringObjectFromLongLong(entry.longval);
            }
            addReplyBulk(c,value);
            decrRefCount(value);
        } else {
            addReply(c,shared.nullbulk);
        }
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb6ea0(%rip), %r15     # 0x1072b0
movq 0x50(%r15), %rdx
callq 0x44f89
testq %rax, %rax
je 0x504c1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
jne 0x504c1
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x44ba1
testl %eax, %eax
jne 0x504c1
movl $0xf0, %eax
andl (%r14), %eax
cmpl $0x90, %eax
jne 0x504cb
movq 0x8(%r14), %rdi
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x26fac
testl %eax, %eax
je 0x50493
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x504a1
movl 0x38(%rsp), %esi
callq 0x43ba8
jmp 0x504ab
movq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x3fc19
jmp 0x504c1
movq 0x30(%rsp), %rdi
callq 0x43bb7
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40537
movq %r14, %rdi
callq 0x440f3
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x75500(%rip), %rdi     # 0xc59d2
leaq 0x75de3(%rip), %rsi     # 0xc62bc
movl $0x148, %edx            # imm = 0x148
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: lsetCommand
void lsetCommand(client *c) {
    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;
    long index;
    robj *value = c->argv[3];

    if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
        return;

    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklist *ql = o->ptr;
        int replaced = quicklistReplaceAtIndex(ql, index,
                                               value->ptr, sdslen(value->ptr));
        if (!replaced) {
            addReply(c,shared.outofrangeerr);
        } else {
            addReply(c,shared.ok);
            signalModifiedKey(c->db,c->argv[1]);
            notifyKeyspaceEvent(NOTIFY_LIST,"lset",c->argv[1],c->db->id);
            server.dirty++;
        }
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb6da9(%rip), %r15     # 0x1072b0
movq 0x78(%r15), %rdx
callq 0x44fbb
testq %rax, %rax
je 0x50616
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
jne 0x50616
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %r12
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x44ba1
testl %eax, %eax
jne 0x50616
movl $0xf0, %eax
andl (%r14), %eax
cmpl $0x90, %eax
jne 0x50622
movq 0x8(%r14), %rdi
movq (%rsp), %rsi
movq 0x8(%r12), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x505af
leaq 0x75d1e(%rip), %r8      # 0xc62a8
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
shrl $0x3, %ecx
jmp 0x505b1
movq -0x11(%rdx), %rcx
jmp 0x505b1
movzwl -0x5(%rdx), %ecx
jmp 0x505b1
movl -0x9(%rdx), %ecx
jmp 0x505b1
movzbl -0x3(%rdx), %ecx
jmp 0x505b1
xorl %ecx, %ecx
callq 0x26efb
testl %eax, %eax
je 0x50607
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x3fc19
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6efc1(%rip), %rsi     # 0xbf5ae
movl $0x10, %edi
callq 0x800c9
leaq 0xb625a(%rip), %rax     # 0x106858
incq 0x710(%rax)
jmp 0x50616
movq 0x90(%r15), %rsi
movq %rbx, %rdi
callq 0x3fc19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x753a9(%rip), %rdi     # 0xc59d2
leaq 0x75c8c(%rip), %rsi     # 0xc62bc
movl $0x162, %edx            # imm = 0x162
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: popGenericCommand
void popGenericCommand(client *c, int where) {
    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;

    robj *value = listTypePop(o,where);
    if (value == NULL) {
        addReply(c,shared.nullbulk);
    } else {
        char *event = (where == LIST_HEAD) ? "lpop" : "rpop";

        addReplyBulk(c,value);
        decrRefCount(value);
        notifyKeyspaceEvent(NOTIFY_LIST,event,c->argv[1],c->db->id);
        if (listTypeLength(o) == 0) {
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",
                                c->argv[1],c->db->id);
            dbDelete(c->db,c->argv[1]);
        }
        signalModifiedKey(c->db,c->argv[1]);
        server.dirty++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb6c50(%rip), %r12     # 0x1072b0
movq 0x50(%r12), %rdx
callq 0x44fbb
testq %rax, %rax
je 0x50744
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
jne 0x50744
movq %r14, %rdi
movl %ebp, %esi
callq 0x4fb96
testq %rax, %rax
je 0x5074d
movq %rax, %r15
testl %ebp, %ebp
leaq 0x6eef0(%rip), %rax     # 0xbf59d
leaq 0x6eed1(%rip), %r12     # 0xbf585
cmoveq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40537
movq %r15, %rdi
callq 0x440f3
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
movl $0x10, %edi
movq %r12, %rsi
callq 0x800c9
movq %r14, %rdi
callq 0x4fc1c
testq %rax, %rax
jne 0x50725
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x70dac(%rip), %rsi     # 0xc14b6
movl $0x4, %edi
callq 0x800c9
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x452f3
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
leaq 0xb611b(%rip), %rax     # 0x106858
incq 0x710(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%r12), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3fc19
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: rpoplpushHandlePush
void rpoplpushHandlePush(client *c, robj *dstkey, robj *dstobj, robj *value) {
    /* Create the list if the key does not exist */
    if (!dstobj) {
        dstobj = createQuicklistObject();
        quicklistSetOptions(dstobj->ptr, server.list_max_ziplist_size,
                            server.list_compress_depth);
        dbAdd(c->db,dstkey,dstobj);
    }
    signalModifiedKey(c->db,dstkey);
    listTypePush(dstobj,value,LIST_HEAD);
    notifyKeyspaceEvent(NOTIFY_LIST,"lpush",dstkey,c->db->id);
    /* Always send the pushed value to the client. */
    addReplyBulk(c,value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
jne 0x50cfb
callq 0x43e25
movq %rax, %r12
movq 0x8(%rax), %rdi
leaq 0xb5b7d(%rip), %rax     # 0x106858
movl 0x960(%rax), %esi
movl 0x964(%rax), %edx
callq 0x2e774
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x45007
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x45220
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4faf0
movq 0x10(%r14), %rax
movl 0x30(%rax), %ecx
leaq 0x6e870(%rip), %rsi     # 0xbf592
movl $0x10, %edi
movq %r15, %rdx
callq 0x800c9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40537
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: rpoplpushCommand
void rpoplpushCommand(client *c) {
    robj *sobj, *value;
    if ((sobj = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,sobj,OBJ_LIST)) return;

    if (listTypeLength(sobj) == 0) {
        /* This may only happen after loading very old RDB files. Recent
         * versions of Redis delete keys of empty lists. */
        addReply(c,shared.nullbulk);
    } else {
        robj *dobj = lookupKeyWrite(c->db,c->argv[2]);
        robj *touchedkey = c->argv[1];

        if (dobj && checkType(c,dobj,OBJ_LIST)) return;
        value = listTypePop(sobj,LIST_TAIL);
        /* We saved touched key, and protect it, since rpoplpushHandlePush
         * may change the client command argument vector (it does not
         * currently). */
        incrRefCount(touchedkey);
        rpoplpushHandlePush(c,c->argv[2],dobj,value);

        /* listTypePop returns an object with its refcount incremented */
        decrRefCount(value);

        /* Delete the source list when it is empty */
        notifyKeyspaceEvent(NOTIFY_LIST,"rpop",touchedkey,c->db->id);
        if (listTypeLength(sobj) == 0) {
            dbDelete(c->db,touchedkey);
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",
                                touchedkey,c->db->id);
        }
        signalModifiedKey(c->db,touchedkey);
        decrRefCount(touchedkey);
        server.dirty++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb6550(%rip), %r15     # 0x1072b0
movq 0x50(%r15), %rdx
callq 0x44fbb
testq %rax, %rax
je 0x50d85
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
je 0x50d8f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x4fc1c
testq %rax, %rax
je 0x50e81
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
callq 0x44f66
movq %rax, %r12
movq 0x40(%rbx), %rax
movq 0x8(%rax), %r15
testq %r12, %r12
je 0x50dd5
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x441ab
testl %eax, %eax
jne 0x50d85
movq %r14, %rdi
movl $0x1, %esi
callq 0x4fb96
movq %rax, %r13
movq %r15, %rdi
callq 0x43c0c
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x50caf
movq %r13, %rdi
callq 0x440f3
movq 0x10(%rbx), %rax
movl 0x30(%rax), %ecx
leaq 0x6e76c(%rip), %rsi     # 0xbf585
movl $0x10, %edi
movq %r15, %rdx
callq 0x800c9
movq %r14, %rdi
callq 0x4fc1c
testq %rax, %rax
jne 0x50e5a
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x452f3
movq 0x10(%rbx), %rax
movl 0x30(%rax), %ecx
leaq 0x70669(%rip), %rsi     # 0xc14b6
movl $0x4, %edi
movq %r15, %rdx
callq 0x800c9
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x45220
movq %r15, %rdi
callq 0x440f3
leaq 0xb59e3(%rip), %rax     # 0x106858
incq 0x710(%rax)
jmp 0x50d85
movq 0x50(%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3fc19
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_list.c
// Function: blockForKeys
void blockForKeys(client *c, robj **keys, int numkeys, mstime_t timeout, robj *target) {
    dictEntry *de;
    list *l;
    int j;

    c->bpop.timeout = timeout;
    c->bpop.target = target;

    if (target != NULL) incrRefCount(target);

    for (j = 0; j < numkeys; j++) {
        /* If the key already exists in the dict ignore it. */
        if (dictAdd(c->bpop.keys,keys[j],NULL) != DICT_OK) continue;
        incrRefCount(keys[j]);

        /* And in the other "side", to map keys -> clients */
        de = dictFind(c->db->blocking_keys,keys[j]);
        if (de == NULL) {
            int retval;

            /* For every key we take a list of clients blocked for it */
            l = listCreate();
            retval = dictAdd(c->db->blocking_keys,keys[j],l);
            incrRefCount(keys[j]);
            serverAssertWithInfo(c,keys[j],retval == DICT_OK);
        } else {
            l = dictGetVal(de);
        }
        listAddNodeTail(l,c);
    }
    blockClient(c,BLOCKED_LIST);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, 0x170(%rdi)
movq %r8, 0x180(%rdi)
testq %r8, %r8
je 0x50ec4
movq %r8, %rdi
callq 0x43c0c
testl %ebp, %ebp
jle 0x50f47
movl %ebp, %r12d
xorl %r13d, %r13d
movq 0x178(%rbx), %rdi
movq (%r14,%r13,8), %rsi
xorl %edx, %edx
callq 0x31a95
testl %eax, %eax
jne 0x50f3f
movq (%r14,%r13,8), %rdi
callq 0x43c0c
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rdi
movq (%r14,%r13,8), %rsi
callq 0x31cca
testq %rax, %rax
je 0x50f09
movq 0x8(%rax), %r15
jmp 0x50f34
callq 0x2e33c
movq %rax, %r15
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rdi
movq (%r14,%r13,8), %rsi
movq %r15, %rdx
callq 0x31a95
movl %eax, %ebp
movq (%r14,%r13,8), %rdi
callq 0x43c0c
testl %ebp, %ebp
jne 0x50f62
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e40f
incq %r13
cmpq %r13, %r12
jne 0x50ece
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x80600
movq (%r14,%r13,8), %rsi
leaq 0x72f5f(%rip), %rdx     # 0xc3ecc
leaq 0x75348(%rip), %rcx     # 0xc62bc
movq %rbx, %rdi
movl $0x280, %r8d            # imm = 0x280
callq 0x66380
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x178(%rdi), %rdi
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
je 0x51076
callq 0x320bb
movq %rax, %r14
movq %rax, %rdi
callq 0x32116
testq %rax, %rax
je 0x5100f
movq (%rax), %r15
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x32019
testq %rax, %rax
je 0x5104d
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2e653
movq %r12, %rdi
movq %rax, %rsi
callq 0x2e4f4
cmpq $0x0, 0x28(%r12)
jne 0x5100a
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x31dba
movq %r14, %rdi
jmp 0x50fb7
movq %r14, %rdi
callq 0x321d3
movq 0x178(%rbx), %rdi
xorl %esi, %esi
callq 0x3261e
movq 0x180(%rbx), %rdi
testq %rdi, %rdi
je 0x51041
callq 0x440f3
movq $0x0, 0x180(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x75354(%rip), %rdx     # 0xc63a8
leaq 0x75261(%rip), %rcx     # 0xc62bc
movq %rbx, %rdi
movq %r15, %rsi
movl $0x298, %r8d            # imm = 0x298
callq 0x66380
movl $0x1, %edi
callq 0x263d0
leaq 0x7530f(%rip), %rdx     # 0xc638c
leaq 0x75238(%rip), %rcx     # 0xc62bc
movq %rbx, %rdi
xorl %esi, %esi
movl $0x290, %r8d            # imm = 0x290
jmp 0x51067
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x31cca
testq %rax, %rax
je 0x51107
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x31cca
testq %rax, %rax
jne 0x51107
movl $0x10, %edi
callq 0x3b29d
movq %rax, %r15
movq %rbx, 0x8(%rax)
movq %r14, (%rax)
movq %rbx, %rdi
callq 0x43c0c
leaq 0xb577a(%rip), %rax     # 0x106858
movq 0x918(%rax), %rdi
movq %r15, %rsi
callq 0x2e40f
movq %rbx, %rdi
callq 0x43c0c
movq 0x18(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31a95
testl %eax, %eax
jne 0x5110d
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7529e(%rip), %rdi     # 0xc63b2
leaq 0x751a1(%rip), %rsi     # 0xc62bc
movl $0x2c3, %edx            # imm = 0x2C3
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x18(%rax), %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x8058c
testl %eax, %eax
jne 0x51746
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x44f66
testq %rax, %rax
je 0x516fe
movq %rax, %r14
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x51726
movq %r14, %rdi
callq 0x4fc1c
testq %rax, %rax
je 0x5174e
movq %rbx, %rdi
callq 0x50d45
jmp 0x51746
testb $0x8, 0x98(%rbx)
jne 0x51733
movq 0x40(%rbx), %rsi
movq (%rsp), %rcx
movq 0x10(%rsi), %r8
addq $0x8, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x50e96
jmp 0x51746
leaq 0xb5b83(%rip), %rax     # 0x1072b0
movq 0x70(%rax), %rsi
jmp 0x5173e
leaq 0xb5b76(%rip), %rax     # 0x1072b0
movq 0x50(%rax), %rsi
movq %rbx, %rdi
callq 0x3fc19
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x74c97(%rip), %rdx     # 0xc63ec
leaq 0x74b60(%rip), %rcx     # 0xc62bc
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3be, %r8d            # imm = 0x3BE
callq 0x66380
movl $0x1, %edi
callq 0x263d0
nop
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_set.c
// Function: setTypeAdd
int setTypeAdd(robj *subject, robj *value) {
    long long llval;
    if (subject->encoding == OBJ_ENCODING_HT) {
        if (dictAdd(subject->ptr,value,NULL) == DICT_OK) {
            incrRefCount(value);
            return 1;
        }
    } else if (subject->encoding == OBJ_ENCODING_INTSET) {
        if (isObjectRepresentableAsLongLong(value,&llval) == C_OK) {
            uint8_t success = 0;
            subject->ptr = intsetAdd(subject->ptr,llval,&success);
            if (success) {
                /* Convert to regular set when the intset contains
                 * too many entries. */
                if (intsetLen(subject->ptr) > server.set_max_intset_entries)
                    setTypeConvert(subject,OBJ_ENCODING_HT);
                return 1;
            }
        } else {
            /* Failed to get integer from object, convert to regular set. */
            setTypeConvert(subject,OBJ_ENCODING_HT);

            /* The set *was* an intset and this value is not integer
             * encodable, so dictAdd should always work. */
            serverAssertWithInfo(NULL,value,
                                dictAdd(subject->ptr,value,NULL) == DICT_OK);
            incrRefCount(value);
            return 1;
        }
    } else {
        serverPanic("Unknown set encoding");
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x517ca
cmpl $0x2, %eax
jne 0x51867
movq 0x8(%r14), %rdi
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31a95
testl %eax, %eax
jne 0x5180c
jmp 0x517fe
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x441d1
testl %eax, %eax
je 0x51817
movq %r14, %rdi
movl $0x2, %esi
callq 0x518a9
movq 0x8(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31a95
testl %eax, %eax
jne 0x51881
movq %rbx, %rdi
callq 0x43c0c
movl $0x1, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xf(%rsp), %rbx
movb $0x0, (%rbx)
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x68634
movq %rax, 0x8(%r14)
cmpb $0x0, (%rbx)
je 0x51862
movq %rax, %rdi
callq 0x68a6e
movl %eax, %eax
leaq 0xb500e(%rip), %rcx     # 0x106858
cmpq %rax, 0x940(%rcx)
jae 0x51806
movq %r14, %rdi
movl $0x2, %esi
callq 0x518a9
jmp 0x51806
xorl %r14d, %r14d
jmp 0x5180c
leaq 0x7417c(%rip), %rdi     # 0xc59ea
leaq 0x74bbb(%rip), %rsi     # 0xc6430
movl $0x53, %edx
callq 0x6558d
jmp 0x5189f
leaq 0x74b7c(%rip), %rdx     # 0xc6404
leaq 0x74ba1(%rip), %rcx     # 0xc6430
xorl %edi, %edi
movq %rbx, %rsi
movl $0x4e, %r8d
callq 0x66380
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x62, (%rdi)
jne 0x51993
cmpl $0x2, %esi
jne 0x519ae
leaq 0xb443d(%rip), %rdi     # 0x105d10
xorl %esi, %esi
callq 0x31774
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x68a6e
movl %eax, %esi
movq %r14, %rdi
callq 0x317e2
movq %rbx, %rdi
callq 0x51af7
movq %rax, %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x51b83
cmpl $-0x1, %eax
je 0x51963
movq 0x10(%rsp), %rdi
callq 0x43bb7
movq %rax, %rbp
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x31a95
testl %eax, %eax
je 0x51905
leaq 0x74b74(%rip), %rdx     # 0xc64b6
leaq 0x74ae7(%rip), %rcx     # 0xc6430
xorl %edi, %edi
movq %rbp, %rsi
movl $0x104, %r8d            # imm = 0x104
callq 0x66380
movl $0x1, %edi
callq 0x263d0
movq %r15, %rdi
callq 0x51b67
movl $0xffffff0f, %eax       # imm = 0xFFFFFF0F
andl (%rbx), %eax
orl $0x20, %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x3b3df
movq %r14, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x74ad9(%rip), %rdx     # 0xc6473
leaq 0x74a8f(%rip), %rcx     # 0xc6430
xorl %edi, %edi
movq %rbx, %rsi
movl $0xf5, %r8d
jmp 0x51954
leaq 0x74b24(%rip), %rdi     # 0xc64d9
leaq 0x74a74(%rip), %rsi     # 0xc6430
movl $0x10c, %edx            # imm = 0x10C
callq 0x6558d
jmp 0x51959
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x51a0f
cmpl $0x2, %eax
jne 0x51a54
movq 0x8(%rbx), %rdi
callq 0x31dba
testl %eax, %eax
jne 0x51a21
movq 0x8(%rbx), %rdi
callq 0x3343a
movl $0x1, %ebp
testl %eax, %eax
je 0x51a23
movq 0x8(%rbx), %rdi
callq 0x317b9
jmp 0x51a23
movq %rsp, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x441d1
testl %eax, %eax
je 0x51a2e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x688f4
movq %rax, 0x8(%rbx)
cmpl $0x0, (%r14)
movl $0x1, %ebp
jne 0x51a23
jmp 0x51a21
leaq 0x73f8f(%rip), %rdi     # 0xc59ea
leaq 0x749ce(%rip), %rsi     # 0xc6430
movl $0x66, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x51aa6
cmpl $0x2, %eax
jne 0x51ad5
movq 0x8(%rbx), %rdi
callq 0x31cca
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x51acf
leaq 0x8(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x441d1
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x51acf
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x689dc
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x73f0e(%rip), %rdi     # 0xc59ea
leaq 0x7494d(%rip), %rsi     # 0xc6430
movl $0x74, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x3b29d
movq %rax, %rbx
movq %r14, (%rax)
movl (%r14), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
cmpl $0x6, %eax
je 0x51b33
cmpl $0x2, %eax
jne 0x51b45
movq 0x8(%r14), %rdi
callq 0x320bb
movq %rax, 0x10(%rbx)
jmp 0x51b3a
movl $0x0, 0xc(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x73e9e(%rip), %rdi     # 0xc59ea
leaq 0x748dd(%rip), %rsi     # 0xc6430
movl $0x82, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x6, %eax
je 0x51bbb
cmpl $0x2, %eax
jne 0x51bee
movq 0x10(%rbx), %rdi
callq 0x32116
testq %rax, %rax
je 0x51be3
movq (%rax), %rax
movq %rax, (%r14)
movq $-0x75bcd15, (%r15)     # imm = 0xF8A432EB
jmp 0x51bde
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xc(%rbx)
movq %r15, %rdx
callq 0x68a3c
testb %al, %al
je 0x51be3
movq $0x0, (%r14)
movl 0x8(%rbx), %eax
jmp 0x51be8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x74843(%rip), %rdi     # 0xc6438
leaq 0x74834(%rip), %rsi     # 0xc6430
movl $0xa7, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %rbx
subq $0x10, %rsp
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
callq 0x51b83
cmpl $-0x1, %eax
je 0x51c4e
cmpl $0x2, %eax
je 0x51c40
cmpl $0x6, %eax
jne 0x51c59
movq 0x8(%rsp), %rdi
callq 0x43bb7
movq %rax, %rbx
jmp 0x51c50
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x43c0c
jmp 0x51c50
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x747fc(%rip), %rdi     # 0xc645c
leaq 0x747c9(%rip), %rsi     # 0xc6430
movl $0xc1, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x51cb3
cmpl $0x2, %eax
jne 0x51cd4
movq 0x8(%rbx), %rdi
callq 0x32237
movq (%rax), %rax
movq %rax, (%r15)
movq $-0x75bcd15, (%r14)     # imm = 0xF8A432EB
jmp 0x51cc6
movq 0x8(%rbx), %rdi
callq 0x68a08
movq %rax, (%r14)
movq $0x0, (%r15)
movl (%rbx), %eax
shrl $0x4, %eax
andl $0xf, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x73d0f(%rip), %rdi     # 0xc59ea
leaq 0x7474e(%rip), %rsi     # 0xc6430
movl $0xe0, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %rax
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x51d17
cmpl $0x2, %eax
jne 0x51d24
movq 0x8(%rdi), %rcx
movq 0x48(%rcx), %rax
addq 0x28(%rcx), %rax
jmp 0x51d22
movq 0x8(%rdi), %rdi
callq 0x68a6e
movl %eax, %eax
popq %rcx
retq
leaq 0x73cbf(%rip), %rdi     # 0xc59ea
leaq 0x746fe(%rip), %rsi     # 0xc6430
movl $0xeb, %edx
callq 0x6558d
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x44f66
testq %rax, %rax
je 0x51d90
movq %rax, %r14
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x51db4
leaq 0xb5536(%rip), %rax     # 0x1072b0
movq 0x70(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3fc19
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x51778
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x45007
xorl %ebp, %ebp
cmpl $0x3, 0x38(%rbx)
jl 0x51df7
xorl %ebp, %ebp
movl $0x2, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x4426d
movq 0x40(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x51790
addl %eax, %ebp
incq %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jl 0x51dc4
testl %ebp, %ebp
je 0x51e2c
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6d7a3(%rip), %rsi     # 0xbf5c5
movl $0x20, %edi
callq 0x800c9
movslq %ebp, %rsi
leaq 0xb4a22(%rip), %rax     # 0x106858
addq %rsi, 0x710(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40606
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb5447(%rip), %rax     # 0x1072b0
movq 0x20(%rax), %rdx
callq 0x44fbb
testq %rax, %rax
je 0x51e8e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x441ab
testl %eax, %eax
je 0x51e97
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
cmpl $0x3, 0x38(%rbx)
setge %bpl
jl 0x51ef4
xorl %r15d, %r15d
movl $0x2, %r12d
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x519c8
testl %eax, %eax
je 0x51ed1
incl %r15d
movq %r14, %rdi
callq 0x51cf6
testq %rax, %rax
je 0x51ee3
incq %r12
movslq 0x38(%rbx), %rax
cmpq %rax, %r12
setl %bpl
jl 0x51ead
jmp 0x51ef4
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x452f3
movslq %r15d, %r14
testl %r15d, %r15d
je 0x51f61
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6d6a7(%rip), %rsi     # 0xbf5ca
movl $0x20, %edi
callq 0x800c9
testb $0x1, %bpl
je 0x51f53
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6f56d(%rip), %rsi     # 0xc14b6
movl $0x4, %edi
callq 0x800c9
leaq 0xb48fe(%rip), %rax     # 0x106858
addq %r14, 0x710(%rax)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x40606
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb5147(%rip), %r15     # 0x1072b0
movq 0x20(%r15), %rdx
callq 0x44f89
testq %rax, %rax
je 0x5218e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x441ab
testl %eax, %eax
je 0x52194
popq %rbx
popq %r14
popq %r15
retq
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x4426d
movq 0x40(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x51a76
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movq 0x20(%r15,%rcx,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3fc19
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xb50c8(%rip), %rax     # 0x1072b0
movq 0x20(%rax), %rdx
callq 0x44f89
testq %rax, %rax
je 0x5220d
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x441ab
testl %eax, %eax
je 0x52215
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x51cf6
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40606
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/t_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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x3, %eax
jne 0x52ef2
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x52c32
jle 0x52f11
leaq 0xb43b5(%rip), %rax     # 0x1072b0
movq 0x80(%rax), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3fc19
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0xb4390(%rip), %rax     # 0x1072b0
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x44f89
testq %rax, %rax
je 0x52f48
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x441ab
testl %eax, %eax
je 0x52f50
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x51c7b
cmpl $0x6, %eax
jne 0x52f7b
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x407de
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x40537
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0x45b7d
cmpl $-0x1, %eax
je 0x53509
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0xb3de1(%rip), %rax     # 0x1072b0
movq 0x148(%rax), %rdx
movq %rbx, %rdi
callq 0x44f89
testq %rax, %rax
je 0x53509
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x441ab
testl %eax, %eax
jne 0x53509
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45bfa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %rbx
movl $0x20, %edi
callq 0x3b29d
movq %rax, %rbx
movl $0x1, 0x18(%rax)
movq $0x0, 0x10(%rax)
movl $0x218, %edi            # imm = 0x218
callq 0x3b29d
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rbx)
xorl %ecx, %ecx
movq $0x0, 0x18(%rax,%rcx)
movl $0x0, 0x20(%rax,%rcx)
addq $0x10, %rcx
cmpq $0x200, %rcx            # imm = 0x200
jne 0x53578
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %r14
callq 0x3b3df
testq %r14, %r14
je 0x535ef
movq (%r14), %rdi
movq 0x18(%r14), %r15
callq 0x440f3
movq %r14, %rdi
callq 0x3b3df
movq %r15, %r14
testq %r15, %r15
jne 0x535d3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3b3df