LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/dict.c
// Function: dictNext
dictEntry *dictNext(dictIterator *iter)
{
    while (1) {
        if (iter->entry == NULL) {
            dictht *ht = &iter->d->ht[iter->table];
            if (iter->index == -1 && iter->table == 0) {
                if (iter->safe)
                    iter->d->iterators++;
                else
                    iter->fingerprint = dictFingerprint(iter->d);
            }
            iter->index++;
            if (iter->index >= (long) ht->size) {
                if (dictIsRehashing(iter->d) && iter->table == 0) {
                    iter->table++;
                    iter->index = 0;
                    ht = &iter->d->ht[1];
                } else {
                    break;
                }
            }
            iter->entry = ht->table[iter->index];
        } else {
            iter->entry = iter->nextEntry;
        }
        if (iter->entry) {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->nextEntry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
cmpq $0x0, 0x18(%rdi)
movq %r15, %r12
jne 0x2f0b6
movq (%rbx), %r14
movq 0x8(%rbx), %r12
movl 0x10(%rbx), %ebp
movslq %ebp, %rax
movq %rax, %rcx
shlq $0x5, %rcx
leaq (%r14,%rcx), %r13
addq $0x10, %r13
cmpq $-0x1, %r12
sete %cl
testl %eax, %eax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x2f07b
cmpl $0x0, 0x14(%rbx)
je 0x2f06f
incl 0x58(%r14)
jmp 0x2f07b
movq %r14, %rdi
callq 0x2ef2e
movq %rax, 0x28(%rbx)
incq %r12
movq %r12, 0x8(%rbx)
cmpq 0x8(%r13), %r12
jl 0x2f0ae
xorl %eax, %eax
cmpq $-0x1, 0x50(%r14)
je 0x2f0ce
testl %ebp, %ebp
jne 0x2f0ce
movl $0x1, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x30, %r14
xorl %r12d, %r12d
movq %r14, %r13
shlq $0x3, %r12
addq (%r13), %r12
movq (%r12), %rax
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x2f035
movq 0x10(%rax), %rcx
movq %rcx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/dict.c
// Function: dictReleaseIterator
void dictReleaseIterator(dictIterator *iter)
{
    if (!(iter->index == -1 && iter->table == 0)) {
        if (iter->safe)
            iter->d->iterators--;
        else
            assert(iter->fingerprint == dictFingerprint(iter->d));
    }
    zfree(iter);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1, 0x8(%rdi)
jne 0x2f0f1
cmpl $0x0, 0x10(%rbx)
je 0x2f110
cmpl $0x0, 0x14(%rbx)
je 0x2f0ff
movq (%rbx), %rax
decl 0x58(%rax)
jmp 0x2f110
movq (%rbx), %rdi
movq 0x28(%rbx), %r14
callq 0x2ef2e
cmpq %rax, %r14
jne 0x2f11f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x38413
leaq 0x8d132(%rip), %rdi     # 0xbc258
leaq 0xa0966(%rip), %rsi     # 0xcfa93
movl $0x26b, %edx            # imm = 0x26B
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/dict.c
// Function: dictGetRandomKey
dictEntry *dictGetRandomKey(dict *d)
{
    dictEntry *he, *orighe;
    unsigned int h;
    int listlen, listele;

    if (dictSize(d) == 0) return NULL;
    if (dictIsRehashing(d)) _dictRehashStep(d);
    if (dictIsRehashing(d)) {
        do {
            /* We are sure there are no elements in indexes from 0
             * to rehashidx-1 */
            h = d->rehashidx + (random() % (d->ht[0].size +
                                            d->ht[1].size -
                                            d->rehashidx));
            he = (h >= d->ht[0].size) ? d->ht[1].table[h - d->ht[0].size] :
                                      d->ht[0].table[h];
        } while(he == NULL);
    } else {
        do {
            h = random() & d->ht[0].sizemask;
            he = d->ht[0].table[h];
        } while(he == NULL);
    }

    /* Now we found a non empty bucket, but it is a linked
     * list and we need to get a random element from the list.
     * The only sane way to do so is counting the elements and
     * select a random index. */
    listlen = 0;
    orighe = he;
    while(he) {
        he = he->next;
        listlen++;
    }
    listele = random() % listlen;
    he = orighe;
    while(listele--) he = he->next;
    return he;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
jne 0x2f157
xorl %r14d, %r14d
jmp 0x2f207
movq %rdi, %rbx
movq 0x50(%rdi), %rcx
cmpq $-0x1, %rcx
je 0x2f1ca
cmpl $0x0, 0x58(%rbx)
jne 0x2f181
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2e787
movq 0x50(%rbx), %rcx
cmpq $-0x1, %rcx
je 0x2f1ca
movq %rcx, %r14
callq 0x26a30
movq 0x18(%rbx), %rsi
movq 0x50(%rbx), %rcx
movq 0x38(%rbx), %rdi
addq %rsi, %rdi
subq %rcx, %rdi
xorl %edx, %edx
divq %rdi
addl %edx, %r14d
movq %r14, %rax
subq %rsi, %rax
jae 0x2f1b8
shlq $0x3, %r14
addq 0x10(%rbx), %r14
movq %r14, %rax
jmp 0x2f1c0
shlq $0x3, %rax
addq 0x30(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x2f181
jmp 0x2f1df
callq 0x26a30
movq 0x10(%rbx), %rcx
andl 0x20(%rbx), %eax
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x2f1ca
xorl %ebx, %ebx
movq %r14, %rax
movq 0x10(%rax), %rax
incq %rbx
testq %rax, %rax
jne 0x2f1e4
callq 0x26a30
cqto
idivq %rbx
testq %rdx, %rdx
je 0x2f207
movq 0x10(%r14), %r14
decl %edx
jne 0x2f1ff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/dict.c
// Function: dictEmpty
void dictEmpty(dict *d, void(callback)(void*)) {
    _dictClear(d,&d->ht[0],callback);
    _dictClear(d,&d->ht[1],callback);
    d->rehashidx = -1;
    d->iterators = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq %rbx, %rdx
callq 0x2ee34
leaq 0x30(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2ee34
movq $-0x1, 0x50(%r14)
movl $0x0, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/dict.c
// Function: dictGetStats
void dictGetStats(char *buf, size_t bufsize, dict *d) {
    size_t l;
    char *orig_buf = buf;
    size_t orig_bufsize = bufsize;

    l = _dictGetStatsHt(buf,bufsize,&d->ht[0],0);
    buf += l;
    bufsize -= l;
    if (dictIsRehashing(d) && bufsize > 0) {
        _dictGetStatsHt(buf,bufsize,&d->ht[1],1);
    }
    /* Make sure there is a NULL term at the end. */
    if (orig_bufsize) orig_buf[orig_bufsize-1] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x2f56b
cmpq $-0x1, 0x50(%r15)
setne %cl
movq %rbx, %rsi
subq %rax, %rsi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2f820
addq %r14, %rax
addq $0x30, %r15
movq %rax, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x2f56b
testq %rbx, %rbx
je 0x2f82b
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: authCommand
void authCommand(client *c) {
    if (!server.requirepass) {
        addReplyError(c,"Client sent AUTH, but no password is set");
    } else if (!time_independent_strcmp(c->argv[1]->ptr, server.requirepass)) {
      c->authenticated = 1;
      addReply(c,shared.ok);
    } else {
      c->authenticated = 0;
      addReplyError(c,"invalid password");
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd20c1(%rip), %rsi     # 0x101900
testq %rsi, %rsi
je 0x2f86c
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x33e63
testl %eax, %eax
je 0x2f87c
movl $0x0, 0x9c(%rbx)
leaq 0x8e05f(%rip), %rsi     # 0xbd8c9
jmp 0x2f873
leaq 0x8e02d(%rip), %rsi     # 0xbd8a0
movq %rbx, %rdi
popq %rbx
jmp 0x3cc06
movl $0x1, 0x9c(%rbx)
movq 0xd2a8b(%rip), %rsi     # 0x102318
movq %rbx, %rdi
popq %rbx
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: pingCommand
void pingCommand(client *c) {
    /* The command takes zero or one arguments. */
    if (c->argc > 2) {
        addReplyErrorFormat(c,"wrong number of arguments for '%s' command",
            c->cmd->name);
        return;
    }

    if (c->flags & CLIENT_PUBSUB) {
        addReply(c,shared.mbulkhdr[2]);
        addReplyBulkCBuffer(c,"pong",4);
        if (c->argc == 1)
            addReplyBulkCBuffer(c,"",0);
        else
            addReplyBulk(c,c->argv[1]);
    } else {
        if (c->argc == 1)
            addReply(c,shared.pong);
        else
            addReplyBulk(c,c->argv[1]);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x3, %eax
jl 0x2f8bb
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0x8ddd4(%rip), %rsi     # 0xbd684
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x3cc2d
testb $0x4, 0x9a(%rbx)
jne 0x2f8d9
cmpl $0x1, %eax
jne 0x2f914
movq 0xd2a78(%rip), %rsi     # 0x102348
movq %rbx, %rdi
popq %rbx
jmp 0x3c854
movq 0xe6470(%rip), %rsi     # 0x115d50
movq %rbx, %rdi
callq 0x3c854
leaq 0x8dfeb(%rip), %rsi     # 0xbd8da
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3d346
cmpl $0x1, 0x38(%rbx)
jne 0x2f914
leaq 0x911ac(%rip), %rsi     # 0xc0ab5
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x3d346
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x3d170
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: infoCommand
void infoCommand(client *c) {
    char *section = c->argc == 2 ? c->argv[1]->ptr : "default";

    if (c->argc > 2) {
        addReply(c,shared.syntaxerr);
        return;
    }
    addReplyBulkSds(c, genRedisInfoString(section));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x2, %eax
jne 0x2f94c
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
jmp 0x2f965
jle 0x2f95e
movq 0xd2a3b(%rip), %rsi     # 0x102390
movq %rbx, %rdi
popq %rbx
jmp 0x3c854
leaq 0x8e06e(%rip), %rdi     # 0xbd9d3
callq 0x342b9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x3d386
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: monitorCommand
void monitorCommand(client *c) {
    /* ignore MONITOR if already slave or in monitor mode */
    if (c->flags & CLIENT_SLAVE) return;

    c->flags |= (CLIENT_SLAVE|CLIENT_MONITOR);
    listAddNodeTail(server.monitors,c);
    addReply(c,shared.ok);
}

// Assembly:
movl 0x98(%rdi), %eax
testb $0x1, %al
jne 0x2f9ac
pushq %rbx
movq %rdi, %rbx
orl $0x5, %eax
movl %eax, 0x98(%rdi)
movq 0xd20fc(%rip), %rdi     # 0x101a90
movq %rbx, %rsi
callq 0x2b24b
movq 0xd2975(%rip), %rsi     # 0x102318
movq %rbx, %rdi
popq %rbx
jmp 0x3c854
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: timeCommand
void timeCommand(client *c) {
    struct timeval tv;

    /* gettimeofday() can only fail if &tv is a bad address so we
     * don't check for errors. */
    gettimeofday(&tv,NULL);
    addReplyMultiBulkLen(c,2);
    addReplyBulkLongLong(c,tv.tv_sec);
    addReplyBulkLongLong(c,tv.tv_usec);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x26300
movl $0x2, %esi
movq %rbx, %rdi
callq 0x3d274
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d415
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3d415
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: serverLog
void serverLog(int level, const char *fmt, ...) {
    va_list ap;
    char msg[LOG_MAX_LEN];

    if ((level&0xff) < server.verbosity) return;

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

    serverLogRaw(level,msg);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2fe08
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movzbl %bl, %eax
cmpl 0xd208f(%rip), %eax     # 0x101ea0
jl 0x2fe5d
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r10, %rdx
callq 0x26810
movl %ebx, %edi
movq %r14, %rsi
callq 0x2fc13
addq $0x4d8, %rsp            # imm = 0x4D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: serverLogFromHandler
void serverLogFromHandler(int level, const char *msg) {
    int fd;
    int log_to_stdout = server.logfile[0] == '\0';
    char buf[64];

    if ((level&0xff) < server.verbosity || (log_to_stdout && server.daemonize))
        return;
    fd = log_to_stdout ? STDOUT_FILENO :
                         open(server.logfile, O_APPEND|O_CREAT|O_WRONLY, 0644);
    if (fd == -1) return;
    ll2string(buf,sizeof(buf),getpid());
    if (write(fd,buf,strlen(buf)) == -1) goto err;
    if (write(fd,":signal-handler (",17) == -1) goto err;
    ll2string(buf,sizeof(buf),time(NULL));
    if (write(fd,buf,strlen(buf)) == -1) goto err;
    if (write(fd,") ",2) == -1) goto err;
    if (write(fd,msg,strlen(msg)) == -1) goto err;
    if (write(fd,"\n",1) == -1) goto err;
err:
    if (!log_to_stdout) close(fd);
}

// Assembly:
movzbl %dil, %eax
cmpl 0xd202e(%rip), %eax     # 0x101ea0
jl 0x2ffaa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0xd21bc(%rip), %rdi     # 0x102048
movb (%rdi), %r15b
testb %r15b, %r15b
jne 0x2fea1
cmpl $0x0, 0xd2029(%rip)     # 0x101ec4
jne 0x2ffa0
testb %r15b, %r15b
je 0x2fec3
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x26690
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x2fec8
jmp 0x2ffa0
movl $0x1, %ebp
callq 0x26420
movslq %eax, %rdx
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
callq 0x3ff83
movq %r14, %rdi
callq 0x26500
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x26bb0
cmpq $-0x1, %rax
je 0x2ff94
leaq 0x8cb13(%rip), %rsi     # 0xbca19
movl $0x11, %edx
movl %ebp, %edi
callq 0x26bb0
cmpq $-0x1, %rax
je 0x2ff94
xorl %edi, %edi
callq 0x26cd0
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x3ff83
movq %r14, %rdi
callq 0x26500
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x26bb0
cmpq $-0x1, %rax
je 0x2ff94
leaq 0x9a2d2(%rip), %rsi     # 0xca226
movl $0x2, %edx
movl %ebp, %edi
callq 0x26bb0
cmpq $-0x1, %rax
je 0x2ff94
movq %rbx, %rdi
callq 0x26500
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x26bb0
cmpq $-0x1, %rax
je 0x2ff94
leaq 0x8ef41(%rip), %rsi     # 0xbeec9
movl $0x1, %edx
movl %ebp, %edi
callq 0x26bb0
testb %r15b, %r15b
je 0x2ffa0
movl %ebp, %edi
callq 0x26180
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: ustime
long long ustime(void) {
    struct timeval tv;
    long long ust;

    gettimeofday(&tv, NULL);
    ust = ((long long)tv.tv_sec)*1000000;
    ust += tv.tv_usec;
    return ust;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26300
imulq $0xf4240, (%rbx), %rax  # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: dictEncObjKeyCompare
int dictEncObjKeyCompare(void *privdata, const void *key1,
        const void *key2)
{
    robj *o1 = (robj*) key1, *o2 = (robj*) key2;
    int cmp;

    if (o1->encoding == OBJ_ENCODING_INT &&
        o2->encoding == OBJ_ENCODING_INT)
            return o1->ptr == o2->ptr;

    o1 = getDecodedObject(o1);
    o2 = getDecodedObject(o2);
    cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
    decrRefCount(o1);
    decrRefCount(o2);
    return cmp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl $0xf0, %eax
movl (%rsi), %ecx
andl %eax, %ecx
cmpl $0x10, %ecx
jne 0x3021d
andl (%rbx), %eax
cmpl $0x10, %eax
jne 0x3021d
movq 0x8(%rsi), %rcx
xorl %eax, %eax
cmpq 0x8(%rbx), %rcx
sete %al
jmp 0x30254
movq %rsi, %rdi
callq 0x41026
movq %rax, %r14
movq %rbx, %rdi
callq 0x41026
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq 0x8(%rax), %rdx
callq 0x30022
movl %eax, %ebp
movq %r14, %rdi
callq 0x40c8f
movq %rbx, %rdi
callq 0x40c8f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: dictEncObjHash
unsigned int dictEncObjHash(const void *key) {
    robj *o = (robj*) key;

    if (sdsEncodedObject(o)) {
        return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
    } else {
        if (o->encoding == OBJ_ENCODING_INT) {
            char buf[32];
            int len;

            len = ll2string(buf,32,(long)o->ptr);
            return dictGenHashFunction((unsigned char*)buf, len);
        } else {
            unsigned int hash;

            o = getDecodedObject(o);
            hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
            decrRefCount(o);
            return hash;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x30275
cmpl $0x1, %eax
je 0x3029c
testl %eax, %eax
jne 0x302bc
movq 0x8(%rdi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x30302
leaq 0x8c196(%rip), %rcx     # 0xbc424
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x30304
movq 0x8(%rdi), %rdx
movq %rsp, %rbx
movl $0x20, %esi
movq %rbx, %rdi
callq 0x3ff83
movq %rbx, %rdi
movl %eax, %esi
callq 0x2e5cd
jmp 0x30339
callq 0x41026
movq %rax, %rbx
movq 0x8(%rax), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x30326
leaq 0x8c15b(%rip), %rcx     # 0xbc438
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x30328
movq -0x11(%rdi), %rsi
jmp 0x30304
movzwl -0x5(%rdi), %esi
jmp 0x30304
movl -0x9(%rdi), %esi
jmp 0x30304
movzbl -0x3(%rdi), %esi
jmp 0x30304
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x2e5cd
movq -0x11(%rdi), %rsi
jmp 0x30328
movzwl -0x5(%rdi), %esi
jmp 0x30328
movl -0x9(%rdi), %esi
jmp 0x30328
movzbl -0x3(%rdi), %esi
jmp 0x30328
xorl %esi, %esi
callq 0x2e5cd
movl %eax, %ebp
movq %rbx, %rdi
callq 0x40c8f
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: htNeedsResize
int htNeedsResize(dict *dict) {
    long long size, used;

    size = dictSlots(dict);
    used = dictSize(dict);
    return (size > DICT_HT_INITIAL_SIZE &&
            (used*100/size < HASHTABLE_MIN_FILL));
}

// Assembly:
movq 0x38(%rdi), %rcx
addq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq $0x5, %rcx
jl 0x3036d
movq 0x48(%rdi), %rax
addq 0x28(%rdi), %rax
imulq $0x64, %rax, %rax
cqto
idivq %rcx
movq %rax, %rcx
xorl %eax, %eax
cmpq $0xa, %rcx
setl %al
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: tryResizeHashTables
void tryResizeHashTables(int dbid) {
    if (htNeedsResize(server.db[dbid].dict))
        dictResize(server.db[dbid].dict);
    if (htNeedsResize(server.db[dbid].expires))
        dictResize(server.db[dbid].expires);
}

// Assembly:
pushq %rbx
movq 0xd155a(%rip), %rcx     # 0x1018d0
movslq %edi, %rbx
shlq $0x6, %rbx
movq (%rcx,%rbx), %rdi
movq 0x38(%rdi), %rsi
addq 0x18(%rdi), %rsi
cmpq $0x5, %rsi
jl 0x303b2
movq 0x48(%rdi), %rax
addq 0x28(%rdi), %rax
imulq $0x64, %rax, %rax
cqto
idivq %rsi
cmpq $0x9, %rax
jg 0x303b2
callq 0x2e6d1
movq 0xd151e(%rip), %rcx     # 0x1018d0
movq 0x8(%rcx,%rbx), %rdi
movq 0x38(%rdi), %rcx
addq 0x18(%rdi), %rcx
cmpq $0x5, %rcx
jl 0x303dc
movq 0x48(%rdi), %rax
addq 0x28(%rdi), %rax
imulq $0x64, %rax, %rax
cqto
idivq %rcx
cmpq $0x9, %rax
jle 0x303de
popq %rbx
retq
popq %rbx
jmp 0x2e6d1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: incrementallyRehash
int incrementallyRehash(int dbid) {
    /* Keys dictionary */
    if (dictIsRehashing(server.db[dbid].dict)) {
        dictRehashMilliseconds(server.db[dbid].dict,1);
        return 1; /* already used our millisecond for this loop... */
    }
    /* Expires */
    if (dictIsRehashing(server.db[dbid].expires)) {
        dictRehashMilliseconds(server.db[dbid].expires,1);
        return 1; /* already used our millisecond for this loop... */
    }
    return 0;
}

// Assembly:
pushq %rbx
movq 0xd14e4(%rip), %rax     # 0x1018d0
movslq %edi, %rcx
shlq $0x6, %rcx
movq (%rax,%rcx), %rdi
cmpq $-0x1, 0x50(%rdi)
jne 0x3040c
addq %rcx, %rax
movq 0x8(%rax), %rdi
cmpq $-0x1, 0x50(%rdi)
je 0x3041f
movl $0x1, %ebx
movl $0x1, %esi
callq 0x2e903
movl %ebx, %eax
popq %rbx
retq
xorl %ebx, %ebx
jmp 0x3041b
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: activeExpireCycleTryExpire
int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    long long t = dictGetSignedIntegerVal(de);
    if (now > t) {
        sds key = dictGetKey(de);
        robj *keyobj = createStringObject(key,sdslen(key));

        propagateExpire(db,keyobj);
        dbDelete(db,keyobj);
        notifyKeyspaceEvent(NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        decrRefCount(keyobj);
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
xorl %eax, %eax
cmpq %rdx, 0x8(%rsi)
jge 0x304e4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x30492
leaq 0x8bfdf(%rip), %rcx     # 0xbc44c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x30494
movq -0x11(%rdi), %rsi
jmp 0x30494
movzwl -0x5(%rdi), %esi
jmp 0x30494
movl -0x9(%rdi), %esi
jmp 0x30494
movzbl -0x3(%rdi), %esi
jmp 0x30494
xorl %esi, %esi
callq 0x40744
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x432db
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41e5f
movl 0x30(%rbx), %ecx
leaq 0x8c56f(%rip), %rsi     # 0xbca2b
movl $0x100, %edi            # imm = 0x100
movq %r14, %rdx
callq 0x7c665
movq %r14, %rdi
callq 0x40c8f
incq 0xd1770(%rip)           # 0x101c48
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: trackInstantaneousMetric
void trackInstantaneousMetric(int metric, long long current_reading) {
    long long t = mstime() - server.inst_metric[metric].last_sample_time;
    long long ops = current_reading -
                    server.inst_metric[metric].last_sample_count;
    long long ops_sec;

    ops_sec = t > 0 ? (ops*1000/t) : 0;

    server.inst_metric[metric].samples[server.inst_metric[metric].idx] =
        ops_sec;
    server.inst_metric[metric].idx++;
    server.inst_metric[metric].idx %= STATS_METRIC_SAMPLES;
    server.inst_metric[metric].last_sample_time = mstime();
    server.inst_metric[metric].last_sample_count = current_reading;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x26300
imulq $0xf4240, (%r15), %rax  # imm = 0xF4240
addq 0x8(%r15), %rax
movabsq $0x20c49ba5e353f7cf, %r15 # imm = 0x20C49BA5E353F7CF
imulq %r15
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rcx
addq %rax, %rcx
movslq %ebp, %rax
imulq $0x98, %rax, %rax
leaq 0xd103d(%rip), %rdx     # 0x1018a8
leaq (%rax,%rdx), %r12
addq $0x430, %r12            # imm = 0x430
subq (%r12), %rcx
jle 0x30893
movq %rbx, %rax
subq 0x8(%r12), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %r14
movslq 0x90(%r12), %rax
movq %r14, 0x10(%r12,%rax,8)
leal 0x1(%rax), %ecx
leal 0x10(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $-0x10, %edx
negl %edx
addl %edx, %eax
incl %eax
movl %eax, 0x90(%r12)
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x26300
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
imulq %r15
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, (%r12)
movq %rbx, 0x8(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: getInstantaneousMetric
long long getInstantaneousMetric(int metric) {
    int j;
    long long sum = 0;

    for (j = 0; j < STATS_METRIC_SAMPLES; j++)
        sum += server.inst_metric[metric].samples[j];
    return sum / STATS_METRIC_SAMPLES;
}

// Assembly:
movslq %edi, %rax
imulq $0x98, %rax, %rax
leaq 0xd0f9c(%rip), %rcx     # 0x1018a8
addq %rcx, %rax
addq $0x440, %rax            # imm = 0x440
pxor %xmm0, %xmm0
xorl %ecx, %ecx
movdqu (%rax,%rcx,8), %xmm1
paddq %xmm1, %xmm0
addq $0x2, %rcx
cmpq $0x10, %rcx
jne 0x3091b
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %rcx
leaq 0xf(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x4, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: clientsCronHandleTimeout
int clientsCronHandleTimeout(client *c, mstime_t now_ms) {
    time_t now = now_ms/1000;

    if (server.maxidletime &&
        !(c->flags & CLIENT_SLAVE) &&    /* no timeout for slaves */
        !(c->flags & CLIENT_MASTER) &&   /* no timeout for masters */
        !(c->flags & CLIENT_BLOCKED) &&  /* no timeout for BLPOP */
        !(c->flags & CLIENT_PUBSUB) &&   /* no timeout for Pub/Sub clients */
        (now - c->lastinteraction > server.maxidletime))
    {
        serverLog(LL_VERBOSE,"Closing idle client");
        freeClient(c);
        return 1;
    } else if (c->flags & CLIENT_BLOCKED) {
        /* Blocked OPS timeout is handled with milliseconds resolution.
         * However note that the actual resolution is limited by
         * server.hz. */

        if (c->bpop.timeout != 0 && c->bpop.timeout < now_ms) {
            /* Handle blocking operation specific timeout. */
            replyToBlockedClientTimedOut(c);
            unblockClient(c);
        } else if (server.cluster_enabled) {
            /* Cluster: handle unblock & redirect of clients blocked
             * into keys no longer served by this server. */
            if (clusterRedirectBlockedClientIfNeeded(c))
                unblockClient(c);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xd154b(%rip), %rdi     # 0x101ea4
testq %rdi, %rdi
setne %al
movl 0x98(%rbx), %ecx
testl $0x40013, %ecx          # imm = 0x40013
sete %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x309c1
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
subq 0x88(%rbx), %rdx
cmpq %rdi, %rdx
jle 0x309c1
leaq 0x8c09a(%rip), %rsi     # 0xbca40
movl $0x1, %ebp
movl $0x1, %edi
xorl %eax, %eax
callq 0x2fdad
movq %rbx, %rdi
callq 0x3d73b
jmp 0x30a06
xorl %ebp, %ebp
testb $0x10, %cl
je 0x30a06
movq 0x170(%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %rsi, %rax
setge %al
orb %cl, %al
jne 0x309e9
movq %rbx, %rdi
callq 0x7cd37
jmp 0x309fe
cmpl $0x0, 0xd1854(%rip)     # 0x102244
je 0x30a06
movq %rbx, %rdi
callq 0x6cfba
testl %eax, %eax
je 0x30a06
movq %rbx, %rdi
callq 0x7cca6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: clientsCronResizeQueryBuffer
int clientsCronResizeQueryBuffer(client *c) {
    size_t querybuf_size = sdsAllocSize(c->querybuf);
    time_t idletime = server.unixtime - c->lastinteraction;

    /* There are two conditions to resize the query buffer:
     * 1) Query buffer is > BIG_ARG and too big for latest peak.
     * 2) Client is inactive and the buffer is bigger than 1k. */
    if (((querybuf_size > PROTO_MBULK_BIG_ARG) &&
         (querybuf_size/(c->querybuf_peak+1)) > 2) ||
         (querybuf_size > 1024 && idletime > 2))
    {
        /* Only resize the query buffer if it is actually wasting space. */
        if (sdsavail(c->querybuf) > 1024) {
            c->querybuf = sdsRemoveFreeSpace(c->querybuf);
        }
    }
    /* Reset the peak again to capture the peak memory usage in the next
     * cycle. */
    c->querybuf_peak = 0;
    return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x367a1
movq %rax, %rcx
movq 0xd17fa(%rip), %rsi     # 0x102220
subq 0x88(%rbx), %rsi
cmpq $0x8001, %rax           # imm = 0x8001
jb 0x30a4a
movq 0x30(%rbx), %rdi
incq %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
cmpq $0x2, %rax
ja 0x30a59
cmpq $0x401, %rcx            # imm = 0x401
jb 0x30ab3
cmpq $0x3, %rsi
jl 0x30ab3
movq 0x28(%rbx), %rdi
movzbl -0x1(%rdi), %eax
andl $0x7, %eax
decl %eax
cmpl $0x3, %eax
ja 0x30ab3
leaq 0x8b9ee(%rip), %rcx     # 0xbc460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x2(%rdi), %eax
movzbl -0x3(%rdi), %ecx
jmp 0x30a9f
movl -0x5(%rdi), %eax
subl -0x9(%rdi), %eax
jmp 0x30aa2
movq -0x9(%rdi), %rax
subq -0x11(%rdi), %rax
jmp 0x30aa2
movzwl -0x3(%rdi), %eax
movzwl -0x5(%rdi), %ecx
subq %rcx, %rax
cmpq $0x401, %rax            # imm = 0x401
jb 0x30ab3
callq 0x365fd
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: clientsCron
void clientsCron(void) {
    /* Make sure to process at least numclients/server.hz of clients
     * per call. Since this function is called server.hz times per second
     * we are sure that in the worst case we process all the clients in 1
     * second. */
    int numclients = listLength(server.clients);
    int iterations = numclients/server.hz;
    mstime_t now = mstime();

    /* Process at least a few clients while we are at it, even if we need
     * to process less than CLIENTS_CRON_MIN_ITERATIONS to meet our contract
     * of processing each client once per second. */
    if (iterations < CLIENTS_CRON_MIN_ITERATIONS)
        iterations = (numclients < CLIENTS_CRON_MIN_ITERATIONS) ?
                     numclients : CLIENTS_CRON_MIN_ITERATIONS;

    while(listLength(server.clients) && iterations--) {
        client *c;
        listNode *head;

        /* Rotate the list, take the current head, process.
         * This way if the client must be removed from the list it's the
         * first element and we don't incur into O(N) computation. */
        listRotate(server.clients);
        head = listFirst(server.clients);
        c = listNodeValue(head);
        /* The following functions do different service checks on the client.
         * The protocol is that they return non-zero if the client was
         * terminated. */
        if (clientsCronHandleTimeout(c,now)) continue;
        if (clientsCronResizeQueryBuffer(c)) continue;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xd0fa2(%rip), %rax     # 0x101a70
movq 0x28(%rax), %r14
movl 0xd0df0(%rip), %ebp     # 0x1018c8
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26300
imulq $0xf4240, (%rbx), %rax  # imm = 0xF4240
addq 0x8(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq 0xd0f6c(%rip), %rdi     # 0x101a70
cmpq $0x0, 0x28(%rdi)
je 0x30b73
movq %rdx, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rbx
addq %rax, %rbx
movl %r14d, %eax
cltd
idivl %ebp
cmpl $0x5, %r14d
movl $0x5, %ebp
cmovll %r14d, %ebp
cmpl $0x5, %eax
cmovgel %eax, %ebp
incl %ebp
decl %ebp
je 0x30b73
callq 0x2b507
movq 0xd0f29(%rip), %rax     # 0x101a70
movq (%rax), %rax
movq 0x10(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3094c
testl %eax, %eax
jne 0x30b65
movq %r14, %rdi
callq 0x30a0f
movq 0xd0f04(%rip), %rdi     # 0x101a70
cmpq $0x0, 0x28(%rdi)
jne 0x30b37
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: databasesCron
void databasesCron(void) {
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);

    /* Perform hash tables rehashing if needed, but only if there are no
     * other processes saving the DB on disk. Otherwise rehashing is bad
     * as will cause a lot of copy-on-write of memory pages. */
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
        /* We use global counters so if we stop the computation at a given
         * DB we'll be able to start from the successive in the next
         * cron loop iteration. */
        static unsigned int resize_db = 0;
        static unsigned int rehash_db = 0;
        int dbs_per_call = CRON_DBS_PER_CALL;
        int j;

        /* Don't test more DBs than we have. */
        if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;

        /* Resize */
        for (j = 0; j < dbs_per_call; j++) {
            tryResizeHashTables(resize_db % server.dbnum);
            resize_db++;
        }

        /* Rehash */
        if (server.activerehashing) {
            for (j = 0; j < dbs_per_call; j++) {
                int work_done = incrementallyRehash(rehash_db % server.dbnum);
                rehash_db++;
                if (work_done) {
                    /* If the function did some work, stop here, we'll do
                     * more at the next cron loop. */
                    break;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0xd1325(%rip)     # 0x101eac
je 0x30b9a
cmpq $0x0, 0xd153f(%rip)     # 0x1020d0
jne 0x30b9a
xorl %edi, %edi
callq 0x304e5
cmpl $-0x1, 0xd1437(%rip)    # 0x101fd8
jne 0x30c3c
cmpl $-0x1, 0xd1396(%rip)    # 0x101f44
jne 0x30c3c
movl 0xd12fe(%rip), %ebp     # 0x101eb8
cmpl $0x10, %ebp
movl $0x10, %ebx
cmovll %ebp, %ebx
testl %ebp, %ebp
jle 0x30c3c
movl 0xd1739(%rip), %eax     # 0x102308
movl %ebx, %r14d
xorl %edx, %edx
divl 0xd12de(%rip)           # 0x101eb8
movl %edx, %edi
callq 0x3036e
movl 0xd1721(%rip), %eax     # 0x102308
incl %eax
movl %eax, 0xd1719(%rip)     # 0x102308
decl %r14d
jne 0x30bd2
testl %ebp, %ebp
setle %al
cmpl $0x0, 0xd0cf8(%rip)     # 0x1018f8
sete %cl
orb %al, %cl
jne 0x30c3c
movl 0xd16ff(%rip), %eax     # 0x10230c
decl %ebx
xorl %edx, %edx
divl 0xd12a1(%rip)           # 0x101eb8
movl %edx, %edi
callq 0x303e4
movl %eax, %ecx
movl 0xd16e6(%rip), %eax     # 0x10230c
incl %eax
movl %eax, 0xd16de(%rip)     # 0x10230c
subl $0x1, %ebx
setb %dl
testl %ecx, %ecx
jne 0x30c3c
testb %dl, %dl
je 0x30c0f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: beforeSleep
void beforeSleep(struct aeEventLoop *eventLoop) {
    UNUSED(eventLoop);

    /* Call the Redis Cluster before sleep function. Note that this function
     * may change the state of Redis Cluster (from ok to fail or vice versa),
     * so it's a good idea to call it before serving the unblocked clients
     * later in this function. */
    if (server.cluster_enabled) clusterBeforeSleep();

    /* Run a fast expire cycle (the called function will return
     * ASAP if a fast cycle is not needed). */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);

    /* Send all the slaves an ACK request if at least one client blocked
     * during the previous event loop iteration. */
    if (server.get_ack_from_slaves) {
        robj *argv[3];

        argv[0] = createStringObject("REPLCONF",8);
        argv[1] = createStringObject("GETACK",6);
        argv[2] = createStringObject("*",1); /* Not used argument. */
        replicationFeedSlaves(server.slaves, server.slaveseldb, argv, 3);
        decrRefCount(argv[0]);
        decrRefCount(argv[1]);
        decrRefCount(argv[2]);
        server.get_ack_from_slaves = 0;
    }

    /* Unblock all the clients blocked for synchronous replication
     * in WAIT. */
    if (listLength(server.clients_waiting_acks))
        processClientsWaitingReplicas();

    /* Try to process pending commands for clients that were just unblocked. */
    if (listLength(server.unblocked_clients))
        processUnblockedClients();

    /* Write the AOF buffer on disk */
    flushAppendOnlyFile(0);

    /* Handle writes with pending output buffers. */
    handleClientsWithPendingWrites();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0xd0f5d(%rip)     # 0x102244
je 0x312ee
callq 0x6a07d
cmpl $0x0, 0xd0bb7(%rip)     # 0x101eac
je 0x3130b
cmpq $0x0, 0xd0dd1(%rip)     # 0x1020d0
jne 0x3130b
movl $0x1, %edi
callq 0x304e5
cmpl $0x0, 0xd0e96(%rip)     # 0x1021a8
je 0x31393
leaq 0x8b8d0(%rip), %rdi     # 0xbcbeb
movl $0x8, %esi
callq 0x40744
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0x8b8c2(%rip), %rdi     # 0xbcbf4
movl $0x6, %esi
callq 0x40744
movq %rax, 0x8(%rbx)
leaq 0x8b8b4(%rip), %rdi     # 0xbcbfb
movl $0x1, %esi
callq 0x40744
movq %rax, 0x10(%rbx)
movq 0xd072c(%rip), %rdi     # 0x101a88
movl 0xd0d02(%rip), %esi     # 0x102064
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x441a9
movq (%rbx), %rdi
callq 0x40c8f
movq 0x8(%rbx), %rdi
callq 0x40c8f
movq 0x10(%rbx), %rdi
callq 0x40c8f
movl $0x0, 0xd0e15(%rip)     # 0x1021a8
movq 0xd0e06(%rip), %rax     # 0x1021a0
cmpq $0x0, 0x28(%rax)
je 0x313a6
callq 0x4744f
movq 0xd0e1b(%rip), %rax     # 0x1021c8
cmpq $0x0, 0x28(%rax)
je 0x313b9
callq 0x7cbdb
xorl %edi, %edi
callq 0x5d159
callq 0x3de14
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: lookupCommandByCString
struct redisCommand *lookupCommandByCString(char *s) {
    struct redisCommand *cmd;
    sds name = sdsnew(s);

    cmd = dictFetchValue(server.commands, name);
    sdsfree(name);
    return cmd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x362b0
movq %rax, %rbx
movq 0xcf831(%rip), %rdi     # 0x1018d8
movq %rax, %rsi
callq 0x2ef19
movq %rax, %r14
movq %rbx, %rdi
callq 0x36330
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: restartServer
int restartServer(int flags, mstime_t delay) {
    int j;

    /* Check if we still have accesses to the executable that started this
     * server instance. */
    if (access(server.executable,X_OK) == -1) return C_ERR;

    /* Config rewriting. */
    if (flags & RESTART_SERVER_CONFIG_REWRITE &&
        server.configfile &&
        rewriteConfig(server.configfile) == -1) return C_ERR;

    /* Perform a proper shutdown. */
    if (flags & RESTART_SERVER_GRACEFULLY &&
        prepareForShutdown(SHUTDOWN_NOFLAGS) != C_OK) return C_ERR;

    /* Close all file descriptors, with the exception of stdin, stdout, strerr
     * which are useful if we restart a Redis server which is not daemonized. */
    for (j = 3; j < (int)server.maxclients + 1024; j++) close(j);

    /* Execute the server with the original command line. */
    if (delay) usleep(delay*1000);
    execve(server.executable,server.exec_argv,environ);

    /* If an error occurred here, there is nothing we can do, but exit. */
    _exit(1);

    return C_ERR; /* Never reached. */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0xcf7e3(%rip), %rdi     # 0x1018b8
movl $0x1, %esi
callq 0x26aa0
cmpl $-0x1, %eax
je 0x32117
movl %ebp, %eax
shrb %al
movq 0xcf7c1(%rip), %rdi     # 0x1018b0
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32106
callq 0x5c3c8
cmpl $-0x1, %eax
je 0x32117
testb $0x1, %bpl
je 0x32121
xorl %edi, %edi
callq 0x33cd9
testl %eax, %eax
je 0x32121
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0xfffffc04, 0xd0081(%rip) # imm = 0xFFFFFC04
jl 0x3214e
movl $0x2, %ebp
movl $0x3ff, %r14d           # imm = 0x3FF
incl %ebp
movl %ebp, %edi
callq 0x26180
movl 0xd0065(%rip), %eax     # 0x1021ac
addl %r14d, %eax
cmpl %eax, %ebp
jl 0x32138
testq %rbx, %rbx
je 0x3215e
imull $0x3e8, %ebx, %edi      # imm = 0x3E8
callq 0x26670
movq 0xcf753(%rip), %rdi     # 0x1018b8
movq 0xcf754(%rip), %rsi     # 0x1018c0
movq 0xcadad(%rip), %rax     # 0xfcf20
movq (%rax), %rdx
callq 0x26780
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: checkTcpBacklogSettings
void checkTcpBacklogSettings(void) {
#ifdef HAVE_PROC_SOMAXCONN
    FILE *fp = fopen("/proc/sys/net/core/somaxconn","r");
    char buf[1024];
    if (!fp) return;
    if (fgets(buf,sizeof(buf),fp) != NULL) {
        int somaxconn = atoi(buf);
        if (somaxconn > 0 && somaxconn < server.tcp_backlog) {
            serverLog(LL_WARNING,"WARNING: The TCP backlog setting of %d cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of %d.", server.tcp_backlog, somaxconn);
        }
    }
    fclose(fp);
#endif
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
leaq 0x8b052(%rip), %rdi     # 0xbd388
leaq 0x8d720(%rip), %rsi     # 0xbfa5d
callq 0x26ae0
testq %rax, %rax
je 0x32392
movq %rax, %rbx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x26440
testq %rax, %rax
je 0x3238a
movq %rsp, %rdi
callq 0x26760
testl %eax, %eax
jle 0x3238a
movl 0xcf5db(%rip), %edx     # 0x10194c
cmpl %edx, %eax
jge 0x3238a
leaq 0x8b029(%rip), %rsi     # 0xbd3a5
movl $0x3, %edi
movl %eax, %ecx
xorl %eax, %eax
callq 0x2fdad
movq %rbx, %rdi
callq 0x26a10
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: resetServerStats
void resetServerStats(void) {
    int j;

    server.stat_numcommands = 0;
    server.stat_numconnections = 0;
    server.stat_expiredkeys = 0;
    server.stat_evictedkeys = 0;
    server.stat_keyspace_misses = 0;
    server.stat_keyspace_hits = 0;
    server.stat_fork_time = 0;
    server.stat_fork_rate = 0;
    server.stat_rejected_conn = 0;
    server.stat_sync_full = 0;
    server.stat_sync_partial_ok = 0;
    server.stat_sync_partial_err = 0;
    for (j = 0; j < STATS_METRIC_COUNT; j++) {
        server.inst_metric[j].idx = 0;
        server.inst_metric[j].last_sample_time = mstime();
        server.inst_metric[j].last_sample_count = 0;
        memset(server.inst_metric[j].samples,0,
            sizeof(server.inst_metric[j].samples));
    }
    server.stat_net_input_bytes = 0;
    server.stat_net_output_bytes = 0;
    server.aof_delayed_fsync = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0xcf6df(%rip)    # 0x101c58
movups %xmm0, 0xcf6c8(%rip)    # 0x101c48
movups %xmm0, 0xcf6b1(%rip)    # 0x101c38
movups %xmm0, 0xcf6e2(%rip)    # 0x101c70
movups %xmm0, 0xcf6eb(%rip)    # 0x101c80
movups %xmm0, 0xcf6f4(%rip)    # 0x101c90
xorl %r15d, %r15d
leaq 0xcf302(%rip), %r12     # 0x1018a8
movq %rsp, %rbx
movabsq $0x20c49ba5e353f7cf, %r13 # imm = 0x20C49BA5E353F7CF
leaq (%r15,%r12), %r14
addq $0x438, %r14            # imm = 0x438
movl $0x0, 0x88(%r14)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26300
imulq $0xf4240, (%rsp), %rax  # imm = 0xF4240
addq 0x8(%rsp), %rax
imulq %r13
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, -0x8(%r14)
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x26110
addq $0x98, %r15
cmpq $0x1c8, %r15            # imm = 0x1C8
jne 0x325b3
movq $0x0, 0xcf969(%rip) # 0x101f88
xorps %xmm0, %xmm0
movups %xmm0, 0xcf69f(%rip)    # 0x101cc8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: setupSignalHandlers
void setupSignalHandlers(void) {
    struct sigaction act;

    /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
     * Otherwise, sa_handler is used. */
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = sigShutdownHandler;
    sigaction(SIGTERM, &act, NULL);
    sigaction(SIGINT, &act, NULL);

#ifdef HAVE_BACKTRACE
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
    act.sa_sigaction = sigsegvHandler;
    sigaction(SIGSEGV, &act, NULL);
    sigaction(SIGBUS, &act, NULL);
    sigaction(SIGFPE, &act, NULL);
    sigaction(SIGILL, &act, NULL);
#endif
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x26ac0
movl $0x0, 0x80(%r14)
leaq 0x2bdf(%rip), %rax      # 0x3577b
movq %rax, -0x8(%r14)
movq %rsp, %rbx
movl $0xf, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
movl $0x2, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
movq %r14, %rdi
callq 0x26ac0
movl $0xc0000004, 0x88(%rbx) # imm = 0xC0000004
leaq 0x3072e(%rip), %rax     # 0x63308
movq %rax, (%rbx)
movl $0xb, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
movl $0x7, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
movl $0x8, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
movl $0x4, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x266c0
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: redisOpArrayFree
void redisOpArrayFree(redisOpArray *oa) {
    while(oa->numops) {
        int j;
        redisOp *op;

        oa->numops--;
        op = oa->ops+oa->numops;
        for (j = 0; j < op->argc; j++)
            decrRefCount(op->argv[j]);
        zfree(op->argv);
    }
    zfree(oa->ops);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x32d2f
cltq
movq %rax, %rcx
shlq $0x5, %rcx
decl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rax
leaq (%rcx,%rax), %r14
addq $-0x20, %r14
cmpl $0x0, 0x8(%r14)
jle 0x32d22
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x40c8f
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x32d0a
movq (%r14), %rdi
callq 0x38413
movl 0x8(%rbx), %eax
jmp 0x32ce3
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x38413
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/server.c
// Function: propagate
void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
               int flags)
{
    if (server.aof_state != AOF_OFF && flags & PROPAGATE_AOF)
        feedAppendOnlyFile(cmd,dbid,argv,argc);
    if (flags & PROPAGATE_REPL)
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
testb $0x1, %r15b
je 0x32da1
cmpl $0x0, 0xcf17d(%rip)     # 0x101f10
je 0x32da1
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x5dd38
testb $0x2, %r15b
jne 0x32db2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xceccf(%rip), %rdi     # 0x101a88
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x441a9